@kurotako/gen-typescript 0.1.0

package/dist/index.cjs

@@ -0,0 +1,895 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TypeScriptAliasCycleError: () => TypeScriptAliasCycleError,
+  TypeScriptAliasPublicNameCollisionError: () => TypeScriptAliasPublicNameCollisionError,
+  TypeScriptEnumCollisionError: () => TypeScriptEnumCollisionError,
+  TypeScriptEnumPublicNameCollisionError: () => TypeScriptEnumPublicNameCollisionError,
+  TypeScriptGenError: () => TypeScriptGenError,
+  typescriptGenerator: () => typescriptGenerator
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var TypeScriptGenError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var TypeScriptAliasCycleError = class extends TypeScriptGenError {
+  namespace;
+  aliasNames;
+  constructor(namespace, aliasNames) {
+    const sortedNames = [...aliasNames].sort(
+      (left, right) => left.localeCompare(right)
+    );
+    super(
+      "typescript_alias_cycle",
+      `source type aliases ${sortedNames.map((name) => `'${name}'`).join(", ")} form a direct reference cycle in namespace '${namespace}'; pure TypeScript aliases cannot represent it`
+    );
+    this.namespace = namespace;
+    this.aliasNames = sortedNames;
+  }
+};
+var TypeScriptAliasPublicNameCollisionError = class extends TypeScriptGenError {
+  namespace;
+  names;
+  constructor(namespace, names) {
+    const sortedNames = [...names].sort(
+      (left, right) => left.localeCompare(right)
+    );
+    super(
+      "typescript_alias_public_name_collision",
+      `source type aliases ${sortedNames.map((name) => `'${name}'`).join(", ")} collide with generated public identifiers in namespace '${namespace}'; rename one of the conflicting source definitions`
+    );
+    this.namespace = namespace;
+    this.names = sortedNames;
+  }
+};
+var TypeScriptEnumPublicNameCollisionError = class extends TypeScriptGenError {
+  namespace;
+  names;
+  constructor(namespace, names) {
+    const sortedNames = [...names].sort(
+      (left, right) => left.localeCompare(right)
+    );
+    super(
+      "typescript_enum_public_name_collision",
+      `source enums ${sortedNames.map((name) => `'${name}'`).join(", ")} collide with other public identifiers in namespace '${namespace}'; rename one of the conflicting source definitions`
+    );
+    this.namespace = namespace;
+    this.names = sortedNames;
+  }
+};
+var TypeScriptEnumCollisionError = class extends TypeScriptGenError {
+  enumName;
+  firstOrigin;
+  secondOrigin;
+  constructor(enumName, firstOrigin, secondOrigin) {
+    super(
+      "typescript_enum_collision",
+      `enum '${enumName}' is defined twice with different values (${firstOrigin} vs ${secondOrigin}); rename one of them in the source schema`
+    );
+    this.enumName = enumName;
+    this.firstOrigin = firstOrigin;
+    this.secondOrigin = secondOrigin;
+  }
+};
+
+// src/generator.ts
+var import_config = require("@kurotako/config");
+
+// src/artifact.ts
+var import_ir = require("@kurotako/ir");
+
+// src/names.ts
+var VARIANTS = [
+  "full",
+  "create",
+  "update",
+  "where",
+  "select"
+];
+var FAMILIES = ["flat", "deep"];
+var VARIANT_TOKEN = {
+  full: "",
+  create: "Create",
+  update: "Update",
+  where: "Where",
+  select: "Select"
+};
+var FAMILY_TOKEN = {
+  flat: "",
+  deep: "Deep"
+};
+function typeName(entity, variant = "", family = "") {
+  return `${entity}${variant}${family}Dto`;
+}
+function enumConst(name) {
+  return name;
+}
+function enumTypeName(name) {
+  return name;
+}
+function entityModule(namespace, entity) {
+  return `${namespace}/typescript/${entity}.type`;
+}
+function enumsModule(namespace) {
+  return `${namespace}/typescript/enums`;
+}
+function filtersModule(namespace) {
+  return `${namespace}/typescript/filters`;
+}
+function scalarsModule(namespace) {
+  return `${namespace}/typescript/scalars`;
+}
+function barrelModule(namespace) {
+  return `${namespace}/typescript`;
+}
+
+// src/emit/enums.ts
+function sameValues(a, b) {
+  const left = a.values.map((value) => value.name);
+  const right = b.values.map((value) => value.name);
+  return left.length === right.length && left.every((value, i) => value === right[i]);
+}
+function collectEnums(source) {
+  const byName = /* @__PURE__ */ new Map();
+  const add = (definition, origin) => {
+    const previous = byName.get(definition.name);
+    if (previous === void 0) {
+      byName.set(definition.name, { definition, origin });
+    } else if (!sameValues(previous.definition, definition)) {
+      throw new TypeScriptEnumCollisionError(
+        definition.name,
+        previous.origin,
+        origin
+      );
+    }
+  };
+  for (const definition of Object.values(source.enums))
+    add(definition, "source-level");
+  for (const entity of Object.values(source.entities)) {
+    for (const definition of Object.values(entity.enums ?? {})) {
+      add(definition, `entity '${entity.name}'`);
+    }
+  }
+  return [...byName.values()].map(({ definition }) => definition).sort((left, right) => left.name.localeCompare(right.name));
+}
+function emitEnums(source) {
+  const blocks = collectEnums(source).map((definition) => {
+    const values = definition.values.map((value) => JSON.stringify(value.name)).join(", ");
+    const name = enumConst(definition.name);
+    return `export const ${name} = [${values}] as const;
+export type ${enumTypeName(definition.name)} = (typeof ${name})[number];`;
+  });
+  return blocks.length === 0 ? "export {};\n" : `${blocks.join("\n\n")}
+`;
+}
+
+// src/artifact.ts
+function roleStem(variant, family) {
+  const variantStem = variant === "full" ? "" : variant;
+  return family === "flat" ? variantStem : variantStem === "" ? "deep" : `${variantStem}Deep`;
+}
+function entitySymbols(name) {
+  const symbols = {};
+  for (const variant of VARIANTS) {
+    for (const family of FAMILIES) {
+      const stem = roleStem(variant, family);
+      const key = stem === "" ? "type" : `${stem}Type`;
+      symbols[key] = typeName(
+        name,
+        VARIANT_TOKEN[variant],
+        FAMILY_TOKEN[family]
+      );
+    }
+  }
+  return symbols;
+}
+function buildArtifact(ir) {
+  const entities = {};
+  for (const { namespace, entity } of (0, import_ir.iterEntities)(ir)) {
+    entities[`${namespace}.${entity.name}`] = {
+      module: entityModule(namespace, entity.name),
+      symbols: entitySymbols(entity.name)
+    };
+  }
+  const perNamespace = {};
+  for (const [namespace, source] of Object.entries(ir.sources)) {
+    const enums = {};
+    for (const definition of collectEnums(source)) {
+      enums[definition.name] = {
+        constName: enumConst(definition.name),
+        typeName: enumTypeName(definition.name),
+        module: enumsModule(namespace)
+      };
+    }
+    perNamespace[namespace] = {
+      barrelModule: barrelModule(namespace),
+      filtersModule: filtersModule(namespace),
+      scalarsModule: scalarsModule(namespace),
+      enums
+    };
+  }
+  return {
+    entities,
+    extra: {
+      families: ["flat", "deep"],
+      variants: ["full", "create", "update", "where", "select"],
+      perNamespace
+    }
+  };
+}
+
+// src/render/scalars.ts
+var import_ir2 = require("@kurotako/ir");
+function emptyDependencies() {
+  return {
+    enums: /* @__PURE__ */ new Set(),
+    entityRefs: /* @__PURE__ */ new Set(),
+    aliases: /* @__PURE__ */ new Set(),
+    usesJsonValue: false
+  };
+}
+function collectTypeDependencies(type, source, entity, into = emptyDependencies()) {
+  switch (type.kind) {
+    case "enum": {
+      const definition = (0, import_ir2.resolveEnum)(source, entity, type.ref);
+      into.enums.add(definition?.name ?? type.ref);
+      break;
+    }
+    case "ref":
+      if (source.entities[type.ref] !== void 0) {
+        into.entityRefs.add(type.ref);
+      } else if (source.typeAliases?.[type.ref] !== void 0) {
+        into.aliases.add(type.ref);
+      }
+      break;
+    case "scalar":
+      if ((0, import_ir2.scalarTsType)(type) === "JsonValue") {
+        into.usesJsonValue = true;
+      }
+      break;
+    case "union":
+      for (const variant of type.variants) {
+        collectTypeDependencies(variant, source, entity, into);
+      }
+      break;
+    case "unknown":
+      break;
+  }
+  return into;
+}
+function renderFieldType(type, source) {
+  switch (type.kind) {
+    case "ref":
+      return source.entities[type.ref] !== void 0 ? typeName(type.ref) : type.ref;
+    case "union": {
+      const variants = (0, import_ir2.flattenUnion)(type);
+      return variants.length === 0 ? "unknown" : variants.map(
+        (variant) => variant.kind === "union" ? `(${renderFieldType(variant, source)})` : renderFieldType(variant, source)
+      ).join(" | ");
+    }
+    case "scalar":
+    case "enum":
+    case "unknown":
+      return (0, import_ir2.scalarTsType)(type);
+  }
+}
+function fieldTsType(field, source, entity) {
+  collectTypeDependencies(field.type, source, entity);
+  return renderFieldType(field.type, source);
+}
+
+// src/emit/aliases.ts
+function emitAliases(source) {
+  const aliases = Object.values(source.typeAliases ?? {});
+  const enums = /* @__PURE__ */ new Set();
+  const entityRefs = /* @__PURE__ */ new Set();
+  let usesJsonValue = false;
+  for (const alias of aliases) {
+    const dependencies = collectTypeDependencies(alias.type, source, void 0);
+    for (const name of dependencies.enums) enums.add(name);
+    for (const name of dependencies.entityRefs) entityRefs.add(name);
+    usesJsonValue ||= dependencies.usesJsonValue;
+  }
+  const imports = [];
+  if (enums.size > 0) {
+    imports.push({ specifier: "./enums", names: [...enums] });
+  }
+  if (usesJsonValue) {
+    imports.push({ specifier: "./scalars", names: ["JsonValue"] });
+  }
+  for (const ref of entityRefs) {
+    imports.push({
+      specifier: `./${ref}.type`,
+      names: [typeName(ref)]
+    });
+  }
+  const blocks = aliases.map((alias) => {
+    const doc = alias.doc === void 0 ? "" : `/** ${alias.doc} */
+`;
+    return `${doc}export type ${alias.name} = ${renderFieldType(alias.type, source)};`;
+  });
+  const importBlock = imports.sort((left, right) => left.specifier.localeCompare(right.specifier)).map(
+    ({ specifier, names }) => `import type { ${names.sort((left, right) => left.localeCompare(right)).join(", ")} } from '${specifier}';`
+  ).join("\n");
+  return `${[importBlock, ...blocks].filter((block) => block !== "").join("\n\n")}
+`;
+}
+
+// src/emit/barrel.ts
+function emitBarrel(source, emitsScalars, emitsAliases = Object.keys(source.typeAliases ?? {}).length > 0) {
+  const lines = [];
+  if (emitsScalars) lines.push("export type * from './scalars';");
+  lines.push("export * from './enums';");
+  if (emitsAliases) lines.push("export type * from './aliases';");
+  if (Object.keys(source.entities).length > 0) {
+    lines.push("export type * from './filters';");
+  }
+  for (const entity of Object.values(source.entities)) {
+    lines.push(`export type * from './${entity.name}.type';`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/render/jsdoc.ts
+function jsDoc(field) {
+  const tags = [];
+  const constraints = field.constraints;
+  if (constraints.min !== void 0) tags.push(`@min ${constraints.min}`);
+  if (constraints.max !== void 0) tags.push(`@max ${constraints.max}`);
+  if (constraints.minLength !== void 0) {
+    tags.push(`@minLength ${constraints.minLength}`);
+  }
+  if (constraints.maxLength !== void 0) {
+    tags.push(`@maxLength ${constraints.maxLength}`);
+  }
+  if (constraints.regex !== void 0) {
+    tags.push(`@pattern ${constraints.regex}`);
+  }
+  if (constraints.format !== void 0) {
+    tags.push(`@format ${constraints.format}`);
+  }
+  if (constraints.unique) tags.push("@unique");
+  if (field.default?.kind === "value") {
+    tags.push(`@default ${JSON.stringify(field.default.value)}`);
+  }
+  if (field.type.kind === "unknown") {
+    tags.push(
+      field.type.hint === void 0 ? "@see unknown" : `@see unknown: ${field.type.hint}`
+    );
+  }
+  const prose = field.doc?.split("\n") ?? [];
+  if (prose.length === 0 && tags.length === 0) {
+    return "";
+  }
+  const lines = [...prose];
+  if (prose.length > 0 && tags.length > 0) lines.push("");
+  lines.push(...tags);
+  return ["/**", ...lines.map((line) => ` * ${line}`), " */"].join("\n");
+}
+
+// src/render/field.ts
+function memberLine(field, opts, source, entity) {
+  let type = fieldTsType(field, source, entity);
+  if (field.list) {
+    if (type.includes(" | ")) type = `(${type})`;
+    type = `${type}[]`;
+  }
+  if (field.nullable) type = `${type} | null`;
+  const member = `  ${field.name}${opts.optional ? "?" : ""}: ${type};`;
+  const doc = jsDoc(field);
+  const indentedDoc = doc.split("\n").map((line) => `  ${line}`).join("\n");
+  return doc === "" ? member : `${indentedDoc}
+${member}`;
+}
+
+// src/render/relations.ts
+var import_ir3 = require("@kurotako/ir");
+function relationMember(relation, family, variant, opts) {
+  if (family === "flat") return null;
+  if ((0, import_ir3.isCrossSource)(opts.fromNamespace, relation)) {
+    opts.logger?.debug(
+      `gen-typescript: relation '${relation.name}' targets another source ('${relation.target.namespace}.${relation.target.entity}'); degrading to the FK id (flat) in the deep family`
+    );
+    return null;
+  }
+  const target = relation.target.entity;
+  const many = relation.cardinality === "many";
+  if (variant === "where") {
+    const dto = typeName(target, "Where", "Deep");
+    return {
+      type: many ? `{ some?: ${dto}; every?: ${dto}; none?: ${dto} }` : dto,
+      optional: true
+    };
+  }
+  if (variant === "select") {
+    return {
+      type: `boolean | ${typeName(target, "Select", "Deep")}`,
+      optional: true
+    };
+  }
+  return {
+    type: many ? `${typeName(target, VARIANT_TOKEN[variant], "Deep")}[]` : typeName(target, VARIANT_TOKEN[variant], "Deep"),
+    optional: relation.optional || many || variant === "update"
+  };
+}
+
+// src/render/variants.ts
+var import_ir4 = require("@kurotako/ir");
+function variantFields(entity, variant) {
+  switch (variant) {
+    case "full":
+      return entity.fields.map((field) => ({
+        field,
+        optional: field.optional
+      }));
+    case "create":
+      return (0, import_ir4.createFields)(entity).map((field) => ({
+        field,
+        optional: (0, import_ir4.isCreateOptional)(field)
+      }));
+    case "update":
+      return (0, import_ir4.updateFields)(entity).map((field) => ({ field, optional: true }));
+    case "where":
+    case "select":
+      return entity.fields.map((field) => ({ field, optional: true }));
+  }
+}
+function filterClass(field) {
+  if (field.type.kind === "enum") return `Enum${field.type.ref}Filter`;
+  if (field.type.kind !== "scalar") return null;
+  switch (field.type.scalar) {
+    case "string":
+    case "uuid":
+    case "decimal":
+    case "bytes":
+      return "StringFilter";
+    case "int":
+      return "IntFilter";
+    case "float":
+      return "FloatFilter";
+    case "bigint":
+      return "BigIntFilter";
+    case "boolean":
+      return "BoolFilter";
+    case "date":
+    case "datetime":
+      return "DateTimeFilter";
+    case "json":
+      return null;
+  }
+}
+
+// src/emit/entity.ts
+function typeBlock(name, members) {
+  return `export type ${name} = {
+${members.join("\n")}
+};`;
+}
+function relationLine(name, member) {
+  return `  ${name}${member.optional ? "?" : ""}: ${member.type};`;
+}
+function importsFor(enums, aliases, filters, usesJsonValue, siblings) {
+  const imports = [];
+  if (aliases.size > 0) {
+    imports.push({ specifier: "./aliases", names: [...aliases] });
+  }
+  if (enums.size > 0) {
+    imports.push({ specifier: "./enums", names: [...enums] });
+  }
+  if (filters.size > 0) {
+    imports.push({ specifier: "./filters", names: [...filters] });
+  }
+  if (usesJsonValue) {
+    imports.push({ specifier: "./scalars", names: ["JsonValue"] });
+  }
+  for (const [entity, names] of siblings) {
+    imports.push({ specifier: `./${entity}.type`, names: [...names] });
+  }
+  return imports.sort((left, right) => left.specifier.localeCompare(right.specifier)).map(
+    ({ specifier, names }) => `import type { ${names.sort((left, right) => left.localeCompare(right)).join(", ")} } from '${specifier}';`
+  ).join("\n");
+}
+function emitEntity(source, entity, logger) {
+  const usedEnums = /* @__PURE__ */ new Set();
+  const usedAliases = /* @__PURE__ */ new Set();
+  const usedEntityRefs = /* @__PURE__ */ new Set();
+  let usesJsonValue = false;
+  const usedFilters = /* @__PURE__ */ new Set();
+  const siblings = /* @__PURE__ */ new Map();
+  for (const field of entity.fields) {
+    const dependencies = collectTypeDependencies(field.type, source, entity);
+    for (const name of dependencies.enums) usedEnums.add(name);
+    for (const name of dependencies.aliases) usedAliases.add(name);
+    for (const name of dependencies.entityRefs) usedEntityRefs.add(name);
+    usesJsonValue ||= dependencies.usesJsonValue;
+  }
+  const trackSibling = (target, name) => {
+    if (target === entity.name) return;
+    const names = siblings.get(target) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    siblings.set(target, names);
+  };
+  for (const ref of usedEntityRefs) {
+    trackSibling(ref, typeName(ref));
+  }
+  const relation = (relationIndex, variant) => {
+    const current = entity.relations[relationIndex];
+    if (current === void 0) return null;
+    const member = relationMember(current, "deep", variant, {
+      fromNamespace: source.namespace,
+      logger
+    });
+    if (member !== null) {
+      trackSibling(
+        current.target.entity,
+        typeName(current.target.entity, VARIANT_TOKEN[variant], "Deep")
+      );
+    }
+    return member;
+  };
+  const blocks = [];
+  for (const variant of VARIANTS) {
+    for (const family of FAMILIES) {
+      const name = typeName(
+        entity.name,
+        VARIANT_TOKEN[variant],
+        FAMILY_TOKEN[family]
+      );
+      if (variant === "where") {
+        blocks.push(renderWhere(name, family));
+      } else if (variant === "select") {
+        blocks.push(renderSelect(name, family));
+      } else {
+        blocks.push(renderRecord(name, variant, family));
+      }
+    }
+  }
+  const imports = importsFor(
+    usedEnums,
+    usedAliases,
+    usedFilters,
+    usesJsonValue,
+    siblings
+  );
+  return `${[imports, "", ...blocks].join("\n\n").trim()}
+`;
+  function renderRecord(name, variant, family) {
+    const own = variantFields(entity, variant).map(
+      (selection) => memberLine(
+        selection.field,
+        { optional: variant === "update" ? false : selection.optional },
+        source,
+        entity
+      )
+    );
+    const relations = [];
+    if (family === "deep") {
+      for (let index = 0; index < entity.relations.length; index += 1) {
+        const current = entity.relations[index];
+        const member = relation(index, variant);
+        if (current !== void 0 && member !== null) {
+          relations.push(relationLine(current.name, member));
+        }
+      }
+    }
+    if (variant === "update") {
+      const base = `Partial<{
+${own.join("\n")}
+}>`;
+      return relations.length === 0 ? `export type ${name} = ${base};` : `export type ${name} = ${base} & {
+${relations.join("\n")}
+};`;
+    }
+    return typeBlock(name, [...own, ...relations]);
+  }
+  function renderWhere(name, family) {
+    const members = [];
+    for (const field of entity.fields) {
+      const filter = filterClass(field);
+      if (filter === null) continue;
+      usedFilters.add(filter);
+      members.push(`  ${field.name}?: ${filter};`);
+    }
+    if (family === "deep") {
+      for (let index = 0; index < entity.relations.length; index += 1) {
+        const current = entity.relations[index];
+        const member = relation(index, "where");
+        if (current !== void 0 && member !== null) {
+          members.push(relationLine(current.name, member));
+        }
+      }
+    }
+    members.push(
+      `  AND?: ${name} | ${name}[];`,
+      `  OR?: ${name} | ${name}[];`,
+      `  NOT?: ${name} | ${name}[];`
+    );
+    return typeBlock(name, members);
+  }
+  function renderSelect(name, family) {
+    const members = entity.fields.map((field) => `  ${field.name}?: boolean;`);
+    for (let index = 0; index < entity.relations.length; index += 1) {
+      const current = entity.relations[index];
+      if (current === void 0) continue;
+      if (family === "flat") {
+        members.push(`  ${current.name}?: boolean;`);
+        continue;
+      }
+      const member = relation(index, "select");
+      members.push(
+        member === null ? `  ${current.name}?: boolean;` : relationLine(current.name, member)
+      );
+    }
+    return typeBlock(name, members);
+  }
+}
+
+// src/emit/filters.ts
+var import_ir5 = require("@kurotako/ir");
+var EQUALITY_OPS = ["equals", "not"];
+var LIST_OPS = ["in", "notIn"];
+var ORDER_OPS = ["lt", "lte", "gt", "gte"];
+var STRING_OPS = ["contains", "startsWith", "endsWith"];
+var SCALAR_FILTER_ORDER = [
+  "StringFilter",
+  "IntFilter",
+  "FloatFilter",
+  "BigIntFilter",
+  "DateTimeFilter",
+  "BoolFilter"
+];
+function collectFilterNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(source.entities)) {
+    for (const field of entity.fields) {
+      const filter = filterClass(field);
+      if (filter !== null) names.add(filter);
+    }
+  }
+  return names;
+}
+function baseType(name) {
+  switch (name) {
+    case "StringFilter":
+      return (0, import_ir5.scalarTsType)({ kind: "scalar", scalar: "string" });
+    case "IntFilter":
+    case "FloatFilter":
+      return (0, import_ir5.scalarTsType)({ kind: "scalar", scalar: "int" });
+    case "BigIntFilter":
+      return (0, import_ir5.scalarTsType)({ kind: "scalar", scalar: "bigint" });
+    case "DateTimeFilter":
+      return (0, import_ir5.scalarTsType)({ kind: "scalar", scalar: "datetime" });
+    case "BoolFilter":
+      return (0, import_ir5.scalarTsType)({ kind: "scalar", scalar: "boolean" });
+  }
+}
+function operations(name) {
+  if (name === "BoolFilter") return EQUALITY_OPS;
+  if (name === "StringFilter") {
+    return [...EQUALITY_OPS, ...LIST_OPS, ...ORDER_OPS, ...STRING_OPS];
+  }
+  return [...EQUALITY_OPS, ...LIST_OPS, ...ORDER_OPS];
+}
+function emitInterface(name, type, ops) {
+  const members = ops.map((operation) => {
+    const list = LIST_OPS.includes(operation);
+    return `  ${operation}?: ${list ? `${type}[]` : type};`;
+  });
+  return `export interface ${name} {
+${members.join("\n")}
+}`;
+}
+function emitFilters(source) {
+  const scalars = /* @__PURE__ */ new Set();
+  const enums = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(source.entities)) {
+    for (const field of entity.fields) {
+      const filter = filterClass(field);
+      if (filter === null) continue;
+      if (field.type.kind === "enum") enums.add(field.type.ref);
+      else scalars.add(filter);
+    }
+  }
+  const enumNames = [...enums].sort((left, right) => left.localeCompare(right));
+  const blocks = [];
+  for (const name of SCALAR_FILTER_ORDER) {
+    if (scalars.has(name))
+      blocks.push(emitInterface(name, baseType(name), operations(name)));
+  }
+  for (const name of enumNames) {
+    blocks.push(
+      emitInterface(`Enum${name}Filter`, enumTypeName(name), [
+        ...EQUALITY_OPS,
+        ...LIST_OPS
+      ])
+    );
+  }
+  const imports = enumNames.length === 0 ? "" : `import type { ${enumNames.map(enumTypeName).join(", ")} } from './enums';
+
+`;
+  return blocks.length === 0 ? "export {};\n" : `${imports}${blocks.join("\n\n")}
+`;
+}
+
+// src/emit/scalars.ts
+function emitScalars() {
+  return `export type JsonValue =
+  | null
+  | boolean
+  | number
+  | string
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+`;
+}
+
+// src/generator.ts
+function sourceUsesJsonValue(source) {
+  for (const entity of Object.values(source.entities)) {
+    for (const field of entity.fields) {
+      if (collectTypeDependencies(field.type, source, entity).usesJsonValue) {
+        return true;
+      }
+    }
+  }
+  for (const alias of Object.values(source.typeAliases ?? {})) {
+    if (collectTypeDependencies(alias.type, source, void 0).usesJsonValue) {
+      return true;
+    }
+  }
+  return false;
+}
+function cyclicAliasNames(source, cycles) {
+  const aliases = source.typeAliases ?? {};
+  const candidates = Object.keys(aliases).filter(
+    (name) => cycles.has(`${source.namespace}.${name}`)
+  );
+  const candidateSet = new Set(candidates);
+  const references = /* @__PURE__ */ new Map();
+  for (const name of candidates) {
+    const alias = aliases[name];
+    if (alias === void 0) continue;
+    const dependencies = collectTypeDependencies(alias.type, source, void 0);
+    references.set(
+      name,
+      [...dependencies.aliases].filter(
+        (dependency) => candidateSet.has(dependency)
+      )
+    );
+  }
+  const reachesSelf = (start, current, seen) => {
+    for (const next of references.get(current) ?? []) {
+      if (next === start) return true;
+      if (!seen.has(next)) {
+        seen.add(next);
+        if (reachesSelf(start, next, seen)) return true;
+      }
+    }
+    return false;
+  };
+  return candidates.filter((name) => reachesSelf(name, name, /* @__PURE__ */ new Set([name])));
+}
+function generatedPublicNames(source) {
+  const enumNames = new Set(collectEnums(source).map(({ name }) => name));
+  const generatedTypeNames = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(source.entities)) {
+    for (const variant of VARIANTS) {
+      for (const family of FAMILIES) {
+        generatedTypeNames.add(
+          typeName(entity.name, VARIANT_TOKEN[variant], FAMILY_TOKEN[family])
+        );
+      }
+    }
+  }
+  for (const name of collectFilterNames(source)) generatedTypeNames.add(name);
+  if (sourceUsesJsonValue(source)) generatedTypeNames.add("JsonValue");
+  return {
+    enumNames,
+    generatedTypeNames,
+    aliasNames: new Set(Object.keys(source.typeAliases ?? {}))
+  };
+}
+function validateSourceEmission(source, cycles) {
+  const aliasesInCycles = cyclicAliasNames(source, cycles);
+  if (aliasesInCycles.length > 0) {
+    throw new TypeScriptAliasCycleError(source.namespace, aliasesInCycles);
+  }
+  const { enumNames, generatedTypeNames, aliasNames } = generatedPublicNames(source);
+  const aliasCollisions = [...aliasNames].filter(
+    (name) => enumNames.has(name) || generatedTypeNames.has(name)
+  );
+  if (aliasCollisions.length > 0) {
+    throw new TypeScriptAliasPublicNameCollisionError(
+      source.namespace,
+      aliasCollisions
+    );
+  }
+  const enumCollisions = [...enumNames].filter(
+    (name) => generatedTypeNames.has(name) || aliasNames.has(name)
+  );
+  if (enumCollisions.length > 0) {
+    throw new TypeScriptEnumPublicNameCollisionError(
+      source.namespace,
+      enumCollisions
+    );
+  }
+}
+var typescriptGenerator = (0, import_config.defineGenerator)({
+  name: "typescript",
+  generate(ctx) {
+    const files = [];
+    for (const [namespace, source] of Object.entries(ctx.ir.sources)) {
+      validateSourceEmission(source, ctx.cycles);
+      const prefix = `${namespace}/typescript`;
+      const emitsScalars = sourceUsesJsonValue(source);
+      if (emitsScalars) {
+        files.push({ path: `${prefix}/scalars.ts`, content: emitScalars() });
+      }
+      files.push({ path: `${prefix}/enums.ts`, content: emitEnums(source) });
+      if (Object.keys(source.entities).length > 0) {
+        files.push({
+          path: `${prefix}/filters.ts`,
+          content: emitFilters(source)
+        });
+      }
+      if (Object.keys(source.typeAliases ?? {}).length > 0) {
+        files.push({
+          path: `${prefix}/aliases.ts`,
+          content: emitAliases(source)
+        });
+      }
+      for (const entity of Object.values(source.entities)) {
+        files.push({
+          path: `${prefix}/${entity.name}.type.ts`,
+          content: emitEntity(source, entity, ctx.logger)
+        });
+      }
+      files.push({
+        path: `${prefix}/index.ts`,
+        content: emitBarrel(
+          source,
+          emitsScalars,
+          Object.keys(source.typeAliases ?? {}).length > 0
+        )
+      });
+    }
+    return { files, artifact: buildArtifact(ctx.ir) };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeScriptAliasCycleError,
+  TypeScriptAliasPublicNameCollisionError,
+  TypeScriptEnumCollisionError,
+  TypeScriptEnumPublicNameCollisionError,
+  TypeScriptGenError,
+  typescriptGenerator
+});
+//# sourceMappingURL=index.cjs.map