@drzl/cli 4.16.0 → 4.17.0

package/dist/cli.cjs

@@ -547,9 +547,11 @@ ${body}
 // ../generator-json-schema/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
+  DRAFT: () => DRAFT,
   JsonSchemaGenerator: () => JsonSchemaGenerator,
   componentsDocument: () => componentsDocument,
   default: () => index_default2,
+  openApiDocument: () => openApiDocument,
   tableSchemas: () => tableSchemas
 });
 function baseSchema(c, mode, target, checks, sets, lengths) {
@@ -561,7 +563,7 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
       case "custom":
         return {};
       case "buffer":
-        return { type: "string", contentEncoding: "base64" };
+        return base64(target);
       case "tuple":
         return target === "openapi-3.0" ? { type: "array", items: { type: "number" }, minItems: s.length, maxItems: s.length } : {
           type: "array",
@@ -596,19 +598,22 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
   if (c.enumValues && c.enumValues.length) return { enum: [...c.enumValues] };
   const mine = c.arrayDimensions ? [] : checks.filter((k) => k.column === c.name);
   const eq = mine.find((k) => k.operator === "=");
-  if (eq) return { const: eq.kind === "string" ? eq.value : Number(eq.value) };
+  if (eq) {
+    const only = eq.kind === "string" ? eq.value : Number(eq.value);
+    return target === "openapi-3.0" ? { enum: [only] } : { const: only };
+  }
   switch (c.tsType) {
     case "string": {
       const out = { type: "string" };
       if (c.format === "uuid") out.format = UUID_FORMAT;
-      else if (c.format && import_validation_core3.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core3.COLUMN_FORMATS[c.format];
+      else if (c.format && import_validation_core4.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core4.COLUMN_FORMATS[c.format];
       if (c.maxLength !== void 0) out.maxLength = c.maxLength;
       applyByteCap(out, c);
       applyLengths(out, c, lengths);
       return out;
     }
     case "number": {
-      const out = { type: (0, import_validation_core3.isIntegerColumn)(c) ? "integer" : "number" };
+      const out = { type: (0, import_validation_core4.isIntegerColumn)(c) ? "integer" : "number" };
       if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
       return out;
     }
@@ -619,7 +624,7 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
     case "Date":
       return { type: "string", format: "date-time" };
     case "Uint8Array":
-      return { type: "string", contentEncoding: "base64" };
+      return base64(target);
     default:
       return {};
   }
@@ -745,7 +750,7 @@ function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
   };
 }
 function collect(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core3.parseCheck)(k.expression, k.name));
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core4.parseCheck)(k.expression, k.name));
   return {
     checks: parsed.flatMap((p) => p.ok ? p.checks : []),
     sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
@@ -757,11 +762,11 @@ function collect(table) {
 function tableSchemas(table, opts = {}) {
   const target = opts.target ?? "draft-2020-12";
   const parsed = collect(table);
-  const build = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
+  const build2 = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
   return {
-    insert: build((0, import_validation_core3.insertColumns)(table), "insert"),
-    update: build((0, import_validation_core3.updateColumns)(table), "update"),
-    select: build((0, import_validation_core3.selectColumns)(table), "select")
+    insert: build2((0, import_validation_core4.insertColumns)(table), "insert"),
+    update: build2((0, import_validation_core4.updateColumns)(table), "update"),
+    select: build2((0, import_validation_core4.selectColumns)(table), "select")
   };
 }
 function componentsDocument(tables, opts = {}) {
@@ -776,6 +781,217 @@ function componentsDocument(tables, opts = {}) {
   }
   return { schemas };
 }
+function keyColumns2(table) {
+  const names = table.primaryKey?.columns ?? [];
+  if (!names.length) return null;
+  const cols = names.map((n) => table.columns.find((c) => c.name === n));
+  if (cols.some((c) => !c)) return null;
+  return cols;
+}
+function foreignKeysOf(table) {
+  if (table.foreignKeys?.length) return table.foreignKeys;
+  return table.columns.filter((c) => c.references).map((c) => ({
+    columns: [c.name],
+    foreignTable: c.references.table,
+    foreignColumns: [c.references.column]
+  }));
+}
+function build(tables, opts) {
+  const target = opts.target ?? "draft-2020-12";
+  const schemaTarget = target === "openapi-3.0" ? "openapi-3.0" : "openapi-3.1";
+  const failure = String(opts.validationStatus ?? 400);
+  const paths = {};
+  const schemas = {};
+  const tags = [];
+  const operationIds = /* @__PURE__ */ new Map();
+  const owner = /* @__PURE__ */ new Map();
+  const claim = (path6, by, label) => {
+    const taken = owner.get(path6);
+    if (taken !== void 0 && taken.by !== by) {
+      throw new Error(
+        `@drzl/generator-json-schema: the OpenAPI path "${path6}" is claimed twice: by table "${taken.label}" (exported as ${taken.by}) and by table "${label}" (exported as ${by}). A path names one resource, so one of the two has to be left out of this generator with the config's "exclude" list.`
+      );
+    }
+    owner.set(path6, { by, label });
+  };
+  const operation = (id, table, rest) => {
+    const clash = operationIds.get(id);
+    if (clash !== void 0) {
+      throw new Error(
+        `@drzl/generator-json-schema: the operationId "${id}" would be emitted for both "${clash}" and "${table.name}". An operationId is the method name a client generator derives, and the specification requires it to be unique across the document.`
+      );
+    }
+    operationIds.set(id, table.name);
+    return { operationId: id, tags: [table.name], ...rest };
+  };
+  const built = tables.map((table) => ({
+    table,
+    key: keyColumns2(table),
+    segment: resourceSegment(table),
+    schemas: tableSchemas(table, { target: schemaTarget, applyDefaults: opts.applyDefaults })
+  }));
+  for (const { table, key, segment, schemas: built3 } of built) {
+    for (const mode of modesFor(table, key)) {
+      const { $schema: _dialect, $id: _id, ...rest } = built3[mode];
+      schemas[componentName(table, mode)] = rest;
+    }
+    const notes = [];
+    if (!key) notes.push("It has no primary key, so no path addresses a single row.");
+    if (table.readOnly) {
+      notes.push("It refuses every write, so only reads are described.");
+    }
+    tags.push({ name: table.name, description: [`Table "${table.name}".`, ...notes].join(" ") });
+    const T = pascal(table.tsName);
+    const select = ref(componentName(table, "select"));
+    const validationFailed = {
+      description: "The request does not match the schema for this operation.",
+      ...jsonBody(ref(ERROR_SCHEMA))
+    };
+    const collidable = [
+      ...table.primaryKey ? [`primary key (${table.primaryKey.columns.join(", ")})`] : [],
+      ...table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
+    ];
+    const conflict = (constraints) => ({
+      description: `The row collides with an existing one on ${constraints.join("; ")}.`,
+      ...jsonBody(ref(ERROR_SCHEMA))
+    });
+    const collection = `/${segment}`;
+    claim(collection, table.tsName, table.name);
+    const item = {
+      get: operation(`list${T}`, table, {
+        summary: `List every ${table.name} row.`,
+        // No pagination parameters. Whether the server implements a limit, an offset or a cursor is
+        // not something a Drizzle schema states, and a declared parameter nothing honours is worse
+        // than an undeclared one.
+        responses: {
+          "200": {
+            description: `Every ${table.name} row.`,
+            ...jsonBody({ type: "array", items: select })
+          }
+        }
+      })
+    };
+    if (!table.readOnly) {
+      item.post = operation(`create${T}`, table, {
+        summary: `Create a ${table.name} row.`,
+        requestBody: { required: true, ...jsonBody(ref(componentName(table, "insert"))) },
+        responses: {
+          "201": { description: `The ${table.name} row that was created.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          ...collidable.length ? { "409": conflict(collidable) } : {}
+        }
+      });
+    }
+    paths[collection] = item;
+    if (!key) continue;
+    const itemPath = `${collection}/${key.map((c) => `{${c.name}}`).join("/")}`;
+    claim(itemPath, table.tsName, table.name);
+    const parameters = key.map((c) => ({
+      name: c.name,
+      in: "path",
+      required: true,
+      description: `${c.name}, from the primary key of ${table.name}.`,
+      // The column's own schema rather than a string, so an integer key is declared as one and a
+      // uuid key carries its format. This is the whole point of reading the real key.
+      schema: built3.select.properties[c.name] ?? {}
+    }));
+    const missing = {
+      description: `No ${table.name} row has that ${key.map((c) => c.name).join(" and ")}.`,
+      ...jsonBody(ref(ERROR_SCHEMA))
+    };
+    const byId = {
+      parameters,
+      get: operation(`get${T}`, table, {
+        summary: `Read one ${table.name} row.`,
+        responses: {
+          "200": { description: `The requested ${table.name} row.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          "404": missing
+        }
+      })
+    };
+    if (!table.readOnly) {
+      byId.patch = operation(`update${T}`, table, {
+        summary: `Patch one ${table.name} row.`,
+        requestBody: { required: true, ...jsonBody(ref(componentName(table, "update"))) },
+        responses: {
+          "200": { description: `The ${table.name} row after the patch.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          "404": missing,
+          // The primary key is not in the update schema, so a patch cannot collide on it. Only a
+          // unique constraint over other columns can.
+          ...table.unique.length ? {
+            "409": conflict(
+              table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
+            )
+          } : {}
+        }
+      });
+      byId.delete = operation(`delete${T}`, table, {
+        summary: `Delete one ${table.name} row.`,
+        responses: {
+          // No body. Handing back the deleted row is the alternative and it is not a true statement
+          // on every dialect DRZL supports: RETURNING is Postgres and SQLite, and MySQL has no such
+          // clause, so an implementation there has nothing to send.
+          "204": { description: `The ${table.name} row was deleted. No content is returned.` },
+          [failure]: validationFailed,
+          "404": missing
+        }
+      });
+    }
+    paths[itemPath] = byId;
+    if (!opts.includeRelations) continue;
+    for (const child of built) {
+      if (child.table === table) continue;
+      const matching = foreignKeysOf(child.table).filter(
+        (fk) => fk.foreignTable === table.name && fk.foreignColumns.length === key.length && fk.foreignColumns.every((c, i) => c === key[i].name)
+      );
+      if (matching.length !== 1) continue;
+      const subPath = `${itemPath}/${child.segment}`;
+      claim(
+        subPath,
+        `${table.tsName} -> ${child.table.tsName}`,
+        `${table.name} -> ${child.table.name}`
+      );
+      paths[subPath] = {
+        parameters,
+        get: operation(`list${T}${pascal(child.table.tsName)}`, child.table, {
+          summary: `List the ${child.table.name} rows belonging to one ${table.name} row.`,
+          responses: {
+            "200": {
+              description: `The ${child.table.name} rows whose ${matching[0].columns.join(", ")} names this ${table.name} row.`,
+              ...jsonBody({ type: "array", items: ref(componentName(child.table, "select")) })
+            },
+            [failure]: validationFailed,
+            "404": missing
+          }
+        })
+      };
+    }
+  }
+  return { paths, schemas, tags };
+}
+function openApiDocument(tables, opts = {}) {
+  const target = opts.target ?? "draft-2020-12";
+  const { paths, schemas, tags } = build(tables, opts);
+  if (ERROR_SCHEMA in schemas) {
+    throw new Error(
+      `@drzl/generator-json-schema: a table produced the component schema name "${ERROR_SCHEMA}", which the document already uses for its error responses.`
+    );
+  }
+  return {
+    openapi: target === "openapi-3.0" ? "3.0.3" : "3.1.1",
+    info: {
+      title: opts.info?.title ?? "API",
+      version: opts.info?.version ?? "0.0.0",
+      description: opts.info?.description ?? "Generated by DRZL from a Drizzle schema. Paths, request bodies and response bodies are derived from the schema alone; nothing here has been checked against a running server."
+    },
+    ...opts.servers?.length ? { servers: opts.servers } : {},
+    paths,
+    components: { schemas: { ...schemas, [ERROR_SCHEMA]: errorSchema() } },
+    tags
+  };
+}
 function renderTableModule(table, affix, target, applyDefaults) {
   const T = table.tsName;
   const schemas = tableSchemas(table, { target, applyDefaults });
@@ -784,6 +1000,12 @@ function renderTableModule(table, affix, target, applyDefaults) {
 export type ${(0, import_validation_core3.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core3.schemaName)(mode, T, affix)};`;
   return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
 }
+function resolveDocument(opt) {
+  if (!opt) return null;
+  const o = opt === true ? {} : opt;
+  if (o.enabled === false) return null;
+  return { ...o, format: o.format ?? "ts" };
+}
 function buildHeader2(h) {
   if (h?.enabled === false) return "";
   const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
@@ -791,14 +1013,38 @@ function buildHeader2(h) {
 
 `;
 }
-var import_validation_core3, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default2;
+var import_validation_core3, import_validation_core4, DRAFT, UUID_FORMAT, base64, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default2;
 var init_dist2 = __esm({
   "../generator-json-schema/dist/index.js"() {
     "use strict";
     import_validation_core3 = require("@drzl/validation-core");
-    DEFAULT_FILE_SUFFIX = ".schema.ts";
+    import_validation_core4 = require("@drzl/validation-core");
     DRAFT = "https://json-schema.org/draft/2020-12/schema";
     UUID_FORMAT = "uuid";
+    base64 = (target) => target === "openapi-3.0" ? { type: "string", format: "byte" } : { type: "string", contentEncoding: "base64" };
+    ERROR_SCHEMA = "Error";
+    componentName = (table, mode) => `${table.tsName}${mode[0].toUpperCase()}${mode.slice(1)}`;
+    ref = (name) => ({ $ref: `#/components/schemas/${name}` });
+    pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+    modesFor = (table, key) => [
+      ...table.readOnly ? [] : ["insert"],
+      ...table.readOnly || !key ? [] : ["update"],
+      "select"
+    ];
+    resourceSegment = (table) => encodeURIComponent(table.name);
+    jsonBody = (schema) => ({ content: { "application/json": { schema } } });
+    errorSchema = () => ({
+      title: "error",
+      description: "What an operation returns when it does not return the row.",
+      type: "object",
+      properties: {
+        message: { type: "string" },
+        code: { type: "string" }
+      },
+      required: ["message"],
+      additionalProperties: true
+    });
+    DEFAULT_FILE_SUFFIX = ".schema.ts";
     JsonSchemaGenerator = class {
       constructor(analysis) {
         this.analysis = analysis;
@@ -813,6 +1059,7 @@ var init_dist2 = __esm({
         const affix = (0, import_validation_core3.resolveAffix)(opts);
         const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
         const target = opts.target ?? "draft-2020-12";
+        const document = resolveDocument(opts.document);
         for (const table of this.analysis.tables) {
           const filePath = path6.join(out, (0, import_validation_core3.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
@@ -839,10 +1086,38 @@ var init_dist2 = __esm({
           );
           files.push(componentsPath);
         }
+        if (document) {
+          const built = openApiDocument(this.analysis.tables, {
+            target,
+            applyDefaults: !!opts.applyDefaults,
+            includeRelations: !!opts.includeRelations,
+            info: document.info,
+            servers: document.servers,
+            validationStatus: document.validationStatus
+          });
+          const body = JSON.stringify(built, null, 2);
+          if (document.format !== "json") {
+            const tsPath = path6.join(out, "openapi.ts");
+            const code = `export const openapi = ${body} as const;
+`;
+            await fs3.writeFile(
+              tsPath,
+              await (0, import_validation_core3.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
+              "utf8"
+            );
+            files.push(tsPath);
+          }
+          if (document.format !== "ts") {
+            const jsonPath = path6.join(out, "openapi.json");
+            await fs3.writeFile(jsonPath, body + "\n", "utf8");
+            files.push(jsonPath);
+          }
+        }
+        const ext = opts.importExtension === "none" ? "" : ".js";
         const indexPath = path6.join(out, "index.ts");
-        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core3.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`).concat(
-          opts.components ? [`export * from './components${opts.importExtension === "none" ? "" : ".js"}';`] : []
-        ).join("\n") + "\n";
+        const index = this.analysis.tables.map(
+          (t) => `export * from '${(0, import_validation_core3.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+        ).concat(opts.components ? [`export * from './components${ext}';`] : []).concat(document && document.format !== "json" ? [`export * from './openapi${ext}';`] : []).join("\n") + "\n";
         const indexFormatted = await (0, import_validation_core3.formatCode)(
           buildHeader2(opts.outputHeader) + index,
           indexPath,
@@ -875,6 +1150,46 @@ var import_commander = require("commander");
 var path5 = __toESM(require("path"), 1);
 var import_ora = __toESM(require("ora"), 1);
 
+// src/validation-options.ts
+function validationOptions(g, cfg, outDir, caps = {}) {
+  return {
+    outDir,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    schemaSuffix: g.schemaSuffix,
+    fileSuffix: g.fileSuffix,
+    importExtension: g.importExtension,
+    affix: g.affix,
+    coerceDates: g.coerceDates,
+    applyDefaults: g.applyDefaults,
+    duplicateFinder: g.duplicateFinder,
+    nestedSchemas: g.nestedSchemas,
+    nestedDepth: g.nestedDepth,
+    // Only where the generator can act on them, so an unsupported option is absent rather than
+    // present and ignored.
+    ...caps.schemaTypes ? {
+      // Needed by both: the reference is resolved relative to the emitted file.
+      schemaPath: cfg.schema,
+      typedJson: g.typedJson,
+      typedColumns: g.typedColumns
+    } : {}
+  };
+}
+
+// src/json-schema-options.ts
+function jsonSchemaOptions(g, cfg, outDir) {
+  return {
+    // JSON Schema is data, so nothing it emits references a type from the schema module.
+    ...validationOptions(g, cfg, outDir, { schemaTypes: false }),
+    target: g.target,
+    components: g.components,
+    document: g.document,
+    // Read only while emitting a document, where it adds `/users/{id}/posts`. The per-table
+    // schemas are flat whatever it says.
+    includeRelations: g.includeRelations
+  };
+}
+
 // src/config.ts
 var import_validation_core = require("@drzl/validation-core");
 var fs = __toESM(require("fs"), 1);
@@ -988,6 +1303,35 @@ var GeneratorSchema = import_zod.z.object({
   target: import_zod.z.enum(["draft-2020-12", "openapi-3.1", "openapi-3.0"]).optional(),
   /** Also emit `components.ts` for the `json-schema` generator, ready for an OpenAPI document. */
   components: import_zod.z.boolean().optional(),
+  /**
+   * Also emit the whole OpenAPI document for the `json-schema` generator: paths, verbs, request and
+   * response bodies per table, with `components.schemas` embedded so the file stands alone.
+   *
+   * `true` is the short form. The object form carries the three things a Drizzle schema genuinely
+   * cannot say: what the API is called, where it is served, and which status code that particular
+   * server answers a request that fails its schema with.
+   */
+  document: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      /** `ts` (default) writes a module, `json` the file OpenAPI tooling reads directly. */
+      format: import_zod.z.enum(["ts", "json", "both"]).optional(),
+      info: import_zod.z.object({
+        title: import_zod.z.string().optional(),
+        version: import_zod.z.string().optional(),
+        description: import_zod.z.string().optional()
+      }).strict().optional(),
+      /**
+       * Omitted by default, which the specification reads as a single server at `/`: the
+       * document describes whatever is serving it. A placeholder host would be a fabrication
+       * that tooling then follows.
+       */
+      servers: import_zod.z.array(import_zod.z.object({ url: import_zod.z.string(), description: import_zod.z.string().optional() }).strict()).optional(),
+      /** 400 by default. 422 is the other defensible reading; exactly one is emitted. */
+      validationStatus: import_zod.z.union([import_zod.z.literal(400), import_zod.z.literal(422)]).optional()
+    }).strict()
+  ]).optional(),
   // service generator specific options
   path: import_zod.z.string().optional(),
   dataAccess: import_zod.z.enum(["stub", "drizzle"]).default("stub").optional(),
@@ -1291,32 +1635,6 @@ function trpcOptions(g, cfg, servicesDir) {
   };
 }
 
-// src/validation-options.ts
-function validationOptions(g, cfg, outDir, caps = {}) {
-  return {
-    outDir,
-    outputHeader: g.outputHeader,
-    format: g.format,
-    schemaSuffix: g.schemaSuffix,
-    fileSuffix: g.fileSuffix,
-    importExtension: g.importExtension,
-    affix: g.affix,
-    coerceDates: g.coerceDates,
-    applyDefaults: g.applyDefaults,
-    duplicateFinder: g.duplicateFinder,
-    nestedSchemas: g.nestedSchemas,
-    nestedDepth: g.nestedDepth,
-    // Only where the generator can act on them, so an unsupported option is absent rather than
-    // present and ignored.
-    ...caps.schemaTypes ? {
-      // Needed by both: the reference is resolved relative to the emitted file.
-      schemaPath: cfg.schema,
-      typedJson: g.typedJson,
-      typedColumns: g.typedColumns
-    } : {}
-  };
-}
-
 // src/drift.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -1719,12 +2037,7 @@ program.command("generate").description("Run configured generators (drzl.config.
           );
           const gen = new JsonSchemaGenerator2(analysis);
           const target = g.path ?? "src/validators/json-schema";
-          const files = await gen.generate({
-            // JSON Schema is data, so nothing here references a type from the schema module.
-            ...validationOptions(g, cfg, target, { schemaTypes: false }),
-            target: g.target,
-            components: g.components
-          });
+          const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
           progress.stop();
           (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (json-schema): ${files.length} files`));
           files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
@@ -2097,12 +2410,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             );
             const gen = new JsonSchemaGenerator2(analysis);
             const target = g.path ?? "src/validators/json-schema";
-            const files = await gen.generate({
-              // JSON Schema is data, so nothing here references a type from the schema module.
-              ...validationOptions(g, cfg, target, { schemaTypes: false }),
-              target: g.target,
-              components: g.components
-            });
+            const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk2.default.green(`Generated (json-schema): ${files.length} files`),
               files.map((f) => import_chalk2.default.cyan(f)).join(", ")