Repository navigation
Expand file tree
/
Copy pathcompiler.ts
More file actions
108 lines (101 loc) · 3.38 KB
/
Copy pathcompiler.ts
File metadata and controls
108 lines (101 loc) · 3.38 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
import { createHash } from "node:crypto";
import { Data, Effect, HashMap, Schema } from "effect";
import { emitProject } from "./emit.js";
import {
OpenApiConfigDecodeError,
OpenApiDocumentDecodeError,
OpenApiEmitError,
type OpenApiEffectError,
} from "./errors.js";
import { normalizeOpenApi } from "./normalize.js";
import { OpenApiEffectConfig } from "./schemas/config.js";
import { OpenApiDocument } from "./schemas/openapi.js";
export class GenerationManifest extends Schema.Class<GenerationManifest>(
"OpenApiEffect.GenerationManifest"
)({
generator: Schema.Literal("@magnitudedev/openapi-effect"),
generatorVersion: Schema.String,
protocolHash: Schema.String,
configHash: Schema.String,
files: Schema.Array(Schema.String),
operations: Schema.Array(Schema.String),
}) {}
const GenerationManifestJson = Schema.parseJson(GenerationManifest, {
space: 2,
});
const ConfigJson = Schema.parseJson(OpenApiEffectConfig);
export class GeneratedProject extends Data.Class<{
readonly files: HashMap.HashMap<string, string>;
readonly manifest: GenerationManifest;
}> {}
const sha256 = (value: string): string =>
createHash("sha256").update(value).digest("hex");
export const decodeOpenApiEffectConfig = (
input: unknown
): Effect.Effect<OpenApiEffectConfig, OpenApiConfigDecodeError> =>
Schema.decodeUnknown(OpenApiEffectConfig)(input, {
onExcessProperty: "error",
}).pipe(Effect.mapError((cause) => new OpenApiConfigDecodeError({ cause })));
export const decodeOpenApiDocument = (
input: unknown
): Effect.Effect<OpenApiDocument, OpenApiDocumentDecodeError> =>
Schema.decodeUnknown(OpenApiDocument)(input, {
onExcessProperty: "error",
}).pipe(
Effect.mapError((cause) => new OpenApiDocumentDecodeError({ cause }))
);
export const compileOpenApi = (
input: unknown,
config: OpenApiEffectConfig
): Effect.Effect<GeneratedProject, OpenApiEffectError> =>
Effect.gen(function* () {
const document = yield* decodeOpenApiDocument(input);
const ir = yield* normalizeOpenApi(document, config);
const emitted = yield* emitProject(ir, config);
const emittedEntries = [...HashMap.entries(emitted.files)].sort(
([left], [right]) => left.localeCompare(right)
);
const configJson = yield* Schema.encode(ConfigJson)(config).pipe(
Effect.mapError(
(cause) =>
new OpenApiEmitError({
module: config.output.manifest,
message: cause.message,
})
)
);
const manifest = new GenerationManifest({
generator: "@magnitudedev/openapi-effect",
generatorVersion: "0.0.1",
protocolHash: sha256(
emittedEntries.map(([path, source]) => `${path}\0${source}`).join("\0")
),
configHash: sha256(configJson),
files: [
...emittedEntries.map(([path]) => path),
config.output.manifest,
].sort(),
operations: [...ir.operations]
.map(({ operationId }) => operationId)
.sort(),
});
const manifestJson = yield* Schema.encode(GenerationManifestJson)(
manifest
).pipe(
Effect.mapError(
(cause) =>
new OpenApiEmitError({
module: config.output.manifest,
message: cause.message,
})
)
);
return new GeneratedProject({
files: HashMap.set(
emitted.files,
config.output.manifest,
`${manifestJson}\n`
),
manifest,
});
});