@deterministic-code/datasources-cli 0.0.0-stage → 0.1.2

package/node_modules/@deterministic-code/generators-common/tsconfig.build.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
+}

package/node_modules/@deterministic-code/generators-openapi/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@deterministic-code/generators-openapi",
+  "version": "0.0.1",
+  "description": "OpenAPI generator pack for the deterministic toolchain: openapi.json emit and language wrappers.",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./generate-openapi-docs": {
+      "types": "./dist/generate-openapi-docs.d.js",
+      "import": "./dist/generate-openapi-docs.js"
+    },
+    "./generate-openapi": {
+      "types": "./dist/generate-openapi.d.js",
+      "import": "./dist/generate-openapi.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.js",
+      "import": "./dist/*.js"
+    },
+    "./*/*": {
+      "types": "./dist/*/*.d.js",
+      "import": "./dist/*/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.build.json"
+  ],
+  "dependencies": {
+    "@deterministic-code/deterministic-specifications-typescript": "github:deterministic-code/deterministic-specifications-typescript#main",
+    "@deterministic-code/generators-common": "0.0.1"
+  }
+}

package/node_modules/@deterministic-code/generators-openapi/src/default-casing.ts

@@ -0,0 +1,15 @@
+import {
+  createCasingStrategy,
+  type ICasingStrategy,
+} from "@deterministic-code/generators-common/casing-strategy";
+
+export const GENERATOR_LANGUAGE = "openapi";
+
+export type PackCasing = ICasingStrategy;
+
+/** Language defaults + settings overrides. Generators call this — not a shared paths.ts. */
+export const createCasing = (
+  settings: Record<string, string>,
+): PackCasing => createCasingStrategy(GENERATOR_LANGUAGE, settings);
+
+export const defaultCasing = createCasing;

package/node_modules/@deterministic-code/generators-openapi/src/generate-openapi-docs.ts

@@ -0,0 +1 @@
+export { generate } from "./generate-openapi.ts";

package/node_modules/@deterministic-code/generators-openapi/src/generate-openapi.integration.test.ts

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { generate } from "./generate-openapi.ts";
+import { loadRoutesApi } from "@deterministic-code/generators-common/routes-api-converter";
+
+const textOf = (entries: GenerateEntry[], path: string): string => {
+  const hit = entries.find((e) => e.kind === "content" && e.filename === path);
+  assert.ok(hit, `missing ${path}`);
+  assert.equal(hit.kind, "content");
+  return hit.contents;
+};
+
+const fixtures = {
+  "types.yaml": `types:
+  - user:
+      tags: [datasource_type, view_type]
+      inherits: set
+      fields:
+        - email:
+            type: string
+`,
+  "datasource.yaml": `includes:
+  - types:
+      filter: tag == "datasource_type"
+types: []
+`,
+  "routes.yaml": `includes:
+  - types:
+      filter: tag == "view_type"
+routes: []
+`,
+};
+
+describe("generate-openapi", () => {
+  it("emits openapi.json for route candidates", async () => {
+    const entries = await generate({
+      reader: memoryReader(fixtures),
+      settings: {
+        application_name: "Demo",
+        "codegen.schema_version": "2.0",
+      },
+    });
+    const json = JSON.parse(textOf(entries, "openapi.json")) as {
+      openapi: string;
+      info: { title: string; version: string };
+      paths: Record<string, unknown>;
+    };
+    assert.equal(json.openapi, "3.0.3");
+    assert.equal(json.info.title, "Demo");
+    assert.equal(json.info.version, "2.0");
+    assert.ok(json.paths["/api/users"]);
+    assert.ok(json.paths["/api/users/{id}"]);
+    assert.equal(
+      (json.paths["/api/users"] as { get?: { operationId?: string } }).get
+        ?.operationId,
+      "userList",
+    );
+    assert.deepEqual(
+      entries.filter((e) => e.kind === "content").map((e) => e.filename),
+      ["openapi.json"],
+    );
+  });
+
+  it("projects OpenAPI from the routes-api IR", async () => {
+    const routesApi = await loadRoutesApi({
+      reader: memoryReader(fixtures),
+      settings: {},
+    });
+    assert.equal(routesApi.version, "1.0.0");
+    assert.ok(routesApi.components.user);
+    assert.equal(
+      (routesApi.components as { schemas?: unknown }).schemas,
+      undefined,
+    );
+    const list = routesApi.routes.find(
+      (entry) =>
+        entry !== null && typeof entry === "object" && "userList" in entry,
+    ) as {
+      userList: {
+        path: string;
+        method: string;
+        entity: string;
+        isCustom: boolean;
+        response: { name: string; schema: { $ref: string } | null };
+      };
+    };
+    assert.equal(list.userList.path, "/api/users");
+    assert.equal(list.userList.method, "GET");
+    assert.equal(list.userList.entity, "user");
+    assert.equal(list.userList.isCustom, false);
+    assert.equal(list.userList.response.name, "user");
+    assert.equal(
+      list.userList.response.schema?.$ref,
+      "#/components/schemas/user",
+    );
+  });
+
+  it("rejects a missing routes.yaml", async () => {
+    await assert.rejects(
+      () => generate({ reader: memoryReader({}), settings: {} }),
+      /routes\.yaml/,
+    );
+  });
+});

package/node_modules/@deterministic-code/generators-openapi/src/generate-openapi.samples.test.ts

@@ -0,0 +1,279 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { describe, it } from "node:test";
+import { memoryReader } from "@deterministic-code/generators-common/deterministic-reader";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { generate } from "./generate-openapi.ts";
+import { loadRoutesApi } from "@deterministic-code/generators-common/routes-api-converter";
+import { DeterministicParser } from "@deterministic-code/deterministic-specifications-typescript/parser";
+import type { RoutesApiDoc } from "@deterministic-code/generators-common/routes-api";
+import { OpenApiConverter } from "./openapi-converter.ts";
+import { renderOpenApiFromRoutesApi } from "./openapi-document.ts";
+
+type OpenApiParameter = {
+  name: string;
+  in: string;
+  required?: boolean;
+  schema?: { type?: string; format?: string };
+};
+
+type OpenApiOperation = {
+  operationId?: string;
+  requestBody?: unknown;
+  parameters?: OpenApiParameter[];
+  responses?: Record<string, { description?: string }>;
+};
+
+type OpenApiDoc = {
+  openapi: string;
+  info: { title: string; version: string };
+  tags?: { name: string }[];
+  paths: Record<string, Record<string, OpenApiOperation | undefined>>;
+};
+
+const ifMatchHeader = (
+  op: OpenApiOperation | undefined,
+): OpenApiParameter | undefined =>
+  op?.parameters?.find((p) => p.name === "If-Match" && p.in === "header");
+
+const assertOccWrite = (op: OpenApiOperation | undefined) => {
+  const header = ifMatchHeader(op);
+  assert.ok(header, "expected If-Match header");
+  assert.equal(header.required, true);
+  assert.equal(header.schema?.type, "string");
+  assert.equal(header.schema?.format, "date-time");
+  assert.ok(op?.responses?.["412"]);
+  assert.ok(op?.responses?.["428"]);
+};
+
+const assertNoOcc = (op: OpenApiOperation | undefined) => {
+  assert.equal(ifMatchHeader(op), undefined);
+  assert.equal(op?.responses?.["412"], undefined);
+  assert.equal(op?.responses?.["428"], undefined);
+};
+
+const textOf = (entries: GenerateEntry[], path: string): string => {
+  const hit = entries.find((e) => e.kind === "content" && e.filename === path);
+  assert.ok(hit, `missing ${path}`);
+  assert.equal(hit.kind, "content");
+  return hit.contents;
+};
+
+const loadSample = async (name: string): Promise<Record<string, string>> => {
+  const dir = new URL(`./samples/${name}/`, import.meta.url);
+  const files = [
+    "types.yaml",
+    "datasource.yaml",
+    "routes.yaml",
+  ] as const;
+  const texts = await Promise.all(
+    files.map((file) => readFile(new URL(file, dir), "utf8")),
+  );
+  return {
+    "types.yaml": texts[0]!,
+    "datasource.yaml": texts[1]!,
+    "routes.yaml": texts[2]!,
+  };
+};
+
+const generateSample = async (name: string, settings: Record<string, string> = {}) => {
+  const files = await loadSample(name);
+  const reader = memoryReader(files);
+  const entries = await generate({ reader, settings });
+  const json = JSON.parse(textOf(entries, "openapi.json")) as OpenApiDoc;
+  assert.equal(json.openapi, "3.0.3");
+  return { files, json, reader };
+};
+
+describe("generate-openapi samples", () => {
+  it("1. simple: one entity CRUD catalog", async () => {
+    const { json } = await generateSample("01-simple", {
+      application_name: "Simple",
+      "codegen.schema_version": "1.0",
+    });
+    assert.equal(json.info.title, "Simple");
+    assert.ok(json.paths["/api/users"]);
+    assert.ok(json.paths["/api/users/{id}"]);
+    assert.equal(json.paths["/api/users"].get?.operationId, "userList");
+    assert.equal(json.paths["/api/users"].post?.operationId, "userCreate");
+  });
+
+  it("2. moderate: lookup, by-field, custom, and unresolved bodies", async () => {
+    const { json } = await generateSample("02-moderate", {
+      application_name: "Moderate",
+    });
+    assert.ok(json.paths["/api/roles"]?.get);
+    assert.equal(json.paths["/api/roles"]?.post, undefined);
+    assert.ok(json.paths["/api/users/email/{email}"]);
+    assert.equal(
+      json.paths["/api/users/email/{email}"].get?.operationId,
+      "userGetByEmail",
+    );
+    const ping = json.paths["/api/ping"]?.post;
+    assert.equal(ping?.operationId, "ping");
+    assert.equal(ping?.requestBody, undefined);
+    assertNoOcc(ping);
+    const clone = json.paths["/api/users/{id}/clone/{id}"]?.post;
+    assert.equal(clone?.operationId, "clone_user");
+    assertNoOcc(clone);
+    assertNoOcc(json.paths["/api/users/email/{email}"]?.put);
+    assertNoOcc(json.paths["/api/users/email/{email}"]?.delete);
+  });
+
+  it("3. complex: eager parent-child, nested combined routes, by-name", async () => {
+    const { json, reader } = await generateSample("03-complex", {
+      application_name: "Complex",
+    });
+    const routesApi = await loadRoutesApi({ reader, settings: {} });
+    assert.ok(json.paths["/api/statuses"]?.get);
+    assert.equal(json.paths["/api/statuses"]?.post, undefined);
+    assert.deepEqual(new Set(json.tags?.map((t) => t.name)), new Set([
+      "status",
+      "project",
+      "task",
+    ]));
+    assert.ok(json.paths["/api/projects"]);
+    assert.ok(json.paths["/api/projects/{id}"]);
+    assert.ok(json.paths["/api/projects/name/{name}"]);
+    assert.ok(json.paths["/api/projects/{id}/tasks"]);
+    assert.ok(json.paths["/api/projects/{id}/tasks/{id}"]);
+    assert.ok(routesApi.components.project_eager_body);
+    assert.ok(routesApi.components.project_eager_create_body);
+    assert.ok(json.paths["/api/projects"]?.post?.requestBody);
+  });
+
+  it("4. complex with optimistic concurrency on mutating types", async () => {
+    const { files, json } = await generateSample(
+      "04-complex-optimistic-concurrency",
+      { application_name: "Occ" },
+    );
+    const tables = (
+      await DeterministicParser(
+        memoryReader({
+          "types.yaml": files["types.yaml"]!,
+          "datasource.yaml": files["datasource.yaml"]!,
+        }),
+      ).parse({})
+    ).datasource;
+    assert.equal(
+      tables.find((t) => t.name === "project")?.useOptimisticConcurrency,
+      true,
+    );
+    assert.equal(
+      tables.find((t) => t.name === "task")?.useOptimisticConcurrency,
+      true,
+    );
+    assert.equal(
+      tables.find((t) => t.name === "status")?.useOptimisticConcurrency,
+      undefined,
+    );
+    const projects = json.paths["/api/projects"];
+    const project = json.paths["/api/projects/{id}"];
+    assertOccWrite(project?.put);
+    assertOccWrite(project?.patch);
+    assertOccWrite(project?.delete);
+    assert.deepEqual(
+      project?.put?.parameters?.map((p) => p.name),
+      ["id", "If-Match"],
+    );
+    assertNoOcc(projects?.get);
+    assertNoOcc(projects?.post);
+    assertNoOcc(project?.get);
+    assertOccWrite(json.paths["/api/projects/{id}/tasks/{id}"]?.put);
+    assertOccWrite(json.paths["/api/projects/{id}/tasks/{id}"]?.delete);
+    assertNoOcc(json.paths["/api/projects/{id}/tasks"]?.post);
+    assertNoOcc(json.paths["/api/statuses"]?.get);
+  });
+
+  it("documents If-Match only when optimistic concurrency is on", async () => {
+    const occOn = new OpenApiConverter().convert({
+      version: "1.0.0",
+      routes: [
+        {
+          itemUpdate: {
+            path: "/api/items/{id}",
+            method: "PUT",
+            entity: "item",
+            isCustom: false,
+            optimisticConcurrency: true,
+          },
+        },
+        {
+          itemList: {
+            path: "/api/items",
+            method: "GET",
+            entity: "item",
+            isCustom: false,
+            optimisticConcurrency: true,
+          },
+        },
+      ],
+      components: {},
+    });
+    const occOnDoc = JSON.parse(occOn) as OpenApiDoc;
+    assertOccWrite(occOnDoc.paths["/api/items/{id}"]?.put);
+    assertNoOcc(occOnDoc.paths["/api/items"]?.get);
+
+    const { json: occOff } = await generateSample("01-simple", {
+      "datasource.use_optimistic_concurrency": "false",
+    });
+    assertNoOcc(occOff.paths["/api/users/{id}"]?.put);
+    assertNoOcc(occOff.paths["/api/users/{id}"]?.patch);
+    assertNoOcc(occOff.paths["/api/users/{id}"]?.delete);
+  });
+
+  it("uses OpenAPI defaults and skips invalid routes-api entries", async () => {
+    const { json } = await generateSample("01-simple");
+    assert.equal(json.info.title, "Deterministic Backend API");
+    assert.equal(json.info.version, "0.0.0");
+
+    const empty = new OpenApiConverter().convert({
+      version: "1.0.0",
+      routes: [],
+      components: {},
+    });
+    const emptyDoc = JSON.parse(empty) as OpenApiDoc;
+    assert.equal(emptyDoc.info.title, "Deterministic Backend API");
+    assert.equal(emptyDoc.tags, undefined);
+
+    const untagged = new OpenApiConverter({ groupByEntity: false }).convert({
+      version: "1.0.0",
+      routes: [
+        {
+          userList: {
+            path: "/api/users",
+            method: "GET",
+            entity: "user",
+            isCustom: false,
+          },
+        },
+      ],
+      components: {},
+    });
+    const untaggedDoc = JSON.parse(untagged) as OpenApiDoc;
+    assert.equal(untaggedDoc.tags, undefined);
+    assert.equal(untaggedDoc.paths["/api/users"]?.get?.operationId, "userList");
+
+    const skipped = renderOpenApiFromRoutesApi({
+      routesApi: {
+        version: "1.0.0",
+        routes: [
+          { broken: null },
+          { also: [] },
+          { skip: "not-an-object" },
+          {
+            health: {
+              path: "/api/health",
+              method: "GET",
+              entity: null,
+              isCustom: true,
+            },
+          },
+        ],
+        components: {},
+      } as RoutesApiDoc,
+    });
+    const skippedDoc = JSON.parse(skipped) as OpenApiDoc;
+    assert.deepEqual(Object.keys(skippedDoc.paths), ["/api/health"]);
+  });
+});

package/node_modules/@deterministic-code/generators-openapi/src/generate-openapi.ts

@@ -0,0 +1,20 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  OPENAPI_DOC_DEFAULTS,
+  OpenApiConverter,
+} from "./openapi-converter.ts";
+import { loadRoutesApi } from "@deterministic-code/generators-common/routes-api-converter";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const routesApi = await loadRoutesApi(ctx);
+  const doc = new OpenApiConverter({
+    title: ctx.settings.application_name ?? OPENAPI_DOC_DEFAULTS.title,
+    version:
+      ctx.settings["codegen.schema_version"] ?? OPENAPI_DOC_DEFAULTS.version,
+    settings: ctx.settings,
+  }).convert(routesApi);
+  return [content("openapi.json", doc)];
+};

package/node_modules/@deterministic-code/generators-openapi/src/openapi-converter.ts

@@ -0,0 +1,37 @@
+import {
+  OPENAPI_DOC_DEFAULTS,
+  renderOpenApiFromRoutesApi,
+} from "./openapi-document.ts";
+import type { RoutesApiDoc } from "@deterministic-code/generators-common/routes-api";
+
+export { OPENAPI_DOC_DEFAULTS };
+
+export type OpenApiConverterOptions = {
+  title?: string;
+  version?: string;
+  naming?: string;
+  schemaNaming?: string;
+  groupByEntity?: boolean;
+  settings?: Record<string, string>;
+};
+
+/** Projects a routes-api document into an OpenAPI 3.0.3 JSON document. */
+export class OpenApiConverter {
+  #options: OpenApiConverterOptions;
+
+  constructor(options: OpenApiConverterOptions = {}) {
+    this.#options = options;
+  }
+
+  convert(routesApi: RoutesApiDoc): string {
+    return renderOpenApiFromRoutesApi({
+      routesApi,
+      title: this.#options.title ?? OPENAPI_DOC_DEFAULTS.title,
+      version: this.#options.version ?? OPENAPI_DOC_DEFAULTS.version,
+      naming: this.#options.naming ?? OPENAPI_DOC_DEFAULTS.naming,
+      schemaNaming:
+        this.#options.schemaNaming ?? OPENAPI_DOC_DEFAULTS.schemaNaming,
+      groupByEntity: this.#options.groupByEntity !== false,
+    });
+  }
+}

package/node_modules/@deterministic-code/generators-openapi/src/openapi-document.ts

@@ -0,0 +1,158 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import {
+  namedRoutes,
+  type RoutesApiBody,
+  type RoutesApiDoc,
+  type RoutesApiRouteDef,
+  type RoutesApiSchema,
+} from "@deterministic-code/generators-common/routes-api";
+import { openapiTmpl, operationTmpl } from "./resources/openapi.ts";
+
+export const OPENAPI_DOC_DEFAULTS = Object.freeze({
+  title: "Deterministic Backend API",
+  version: "0.0.0",
+  naming: "original",
+  schemaNaming: "Snake",
+});
+
+const expressParamRe = (): RegExp => /:([A-Za-z_][A-Za-z0-9_]*)/g;
+const braceParamRe = (): RegExp => /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+
+const withLast = <T extends Record<string, unknown>>(
+  items: T[],
+): Array<T & { last: boolean }> =>
+  items.map((item, i) => ({ ...item, last: i === items.length - 1 }));
+
+const indentJson = (value: unknown, indent: number): string => {
+  const pad = " ".repeat(indent);
+  return JSON.stringify(value, null, 2)
+    .split("\n")
+    .map((line, i) => (i === 0 ? line : `${pad}${line}`))
+    .join("\n");
+};
+
+const indentBlock = (text: string, indent: number): string => {
+  const pad = " ".repeat(indent);
+  return text
+    .split("\n")
+    .map((line, i) => (i === 0 ? line : `${pad}${line}`))
+    .join("\n");
+};
+
+const openApiPath = (path: string): string =>
+  path.replace(expressParamRe(), "{$1}");
+
+const pathParamNames = (path: string): string[] => {
+  const names: string[] = [];
+  const seen = new Set<string>();
+  for (const match of openApiPath(path).matchAll(braceParamRe())) {
+    const name = match[1]!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    names.push(name);
+  }
+  return names;
+};
+
+const bodySchema = (
+  body: RoutesApiBody | undefined,
+): { $ref: string } | null =>
+  body?.schema === undefined || body.schema === null ? null : body.schema;
+
+type NamedJson = { nameJson: string };
+
+const namedJson = (name: string): NamedJson => ({
+  nameJson: JSON.stringify(name),
+});
+
+const OCC_METHODS = new Set(["PUT", "PATCH", "DELETE"]);
+
+const operationTokens = (
+  routeName: string,
+  route: RoutesApiRouteDef,
+  groupByEntity: boolean,
+) => {
+  const requestSchema = bodySchema(route.request);
+  const responseSchema = bodySchema(route.response);
+  const parameters = pathParamNames(route.path);
+  const operationTags =
+    groupByEntity && route.entity !== null ? [route.entity] : [];
+  const hasIfMatch =
+    route.optimisticConcurrency === true &&
+    OCC_METHODS.has(route.method.toUpperCase());
+  return {
+    summaryJson: JSON.stringify(routeName),
+    operationIdJson: JSON.stringify(routeName),
+    hasOperationTags: operationTags.length > 0,
+    operationTags: withLast(operationTags.map(namedJson)),
+    hasPathParameters: parameters.length > 0,
+    hasIfMatch,
+    hasParameters: parameters.length > 0 || hasIfMatch,
+    parameters: withLast(parameters.map(namedJson)),
+    hasRequestBody: requestSchema !== null,
+    requestSchemaJson:
+      requestSchema === null ? "" : indentJson(requestSchema, 8),
+    hasResponseBody: responseSchema !== null,
+    responseSchemaJson:
+      responseSchema === null ? "" : indentJson(responseSchema, 8),
+  };
+};
+
+type PathBucket = {
+  path: string;
+  operations: Array<{ method: string; json: string }>;
+};
+
+/** Project a routes-api document into OpenAPI 3.0.3 via templates. */
+export const renderOpenApiFromRoutesApi = ({
+  routesApi,
+  title = OPENAPI_DOC_DEFAULTS.title,
+  version = OPENAPI_DOC_DEFAULTS.version,
+  groupByEntity = true,
+}: {
+  routesApi: RoutesApiDoc;
+  title?: string;
+  version?: string;
+  naming?: string;
+  schemaNaming?: string;
+  groupByEntity?: boolean;
+}): string => {
+  const buckets = new Map<string, PathBucket>();
+  const tagSet = new Set<string>();
+  for (const [routeName, def] of namedRoutes(routesApi.routes)) {
+    const path = openApiPath(def.path);
+    const bucket = buckets.get(path) ?? { path, operations: [] };
+    if (!buckets.has(path)) buckets.set(path, bucket);
+    if (groupByEntity && def.entity !== null) tagSet.add(def.entity);
+    bucket.operations.push({
+      method: def.method.toLowerCase(),
+      json: fill(operationTmpl, operationTokens(routeName, def, groupByEntity)).trimEnd(),
+    });
+  }
+  const docTags = [...tagSet];
+  const schemas = Object.entries(routesApi.components).map(
+    ([name, schema]: [string, RoutesApiSchema]) => ({
+      nameJson: JSON.stringify(name),
+      schemaJson: indentJson(schema, 6),
+    }),
+  );
+  const json = fill(openapiTmpl, {
+    titleJson: JSON.stringify(title),
+    versionJson: JSON.stringify(version),
+    hasDocTags: docTags.length > 0,
+    docTags: withLast(docTags.map(namedJson)),
+    paths: withLast(
+      [...buckets.values()].map((bucket) => ({
+        pathJson: JSON.stringify(bucket.path),
+        operations: withLast(
+          bucket.operations.map((operation) => ({
+            methodJson: JSON.stringify(operation.method),
+            operationJson: indentBlock(operation.json, 6),
+          })),
+        ),
+      })),
+    ),
+    schemas: withLast(schemas),
+  });
+  return `${json.trimEnd()}\n`;
+};

package/node_modules/@deterministic-code/generators-openapi/src/resources/openapi.ts

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+
+const resource = (rel: string): Promise<string> =>
+  readFile(new URL(`../templates/create-openapi/${rel}`, import.meta.url), "utf8");
+
+export const [openapiTmpl, operationTmpl] = await Promise.all([
+  resource("openapi.json.tmpl"),
+  resource("operation.json.tmpl"),
+]);