zero-swift 0.0.0 → 0.1.0

package/dist/bin.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { relative, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+// src/generate.ts
+var reservedTypeNames = /* @__PURE__ */ new Set([
+  "AnyQuery",
+  "Cardinality",
+  "ColumnSchema",
+  "Column",
+  "Condition",
+  "Format",
+  "Indirect",
+  "JSONValue",
+  "KeyPathNames",
+  "Query",
+  "QueryResult",
+  "RelationshipHop",
+  "Row",
+  "RowExpression",
+  "TableSchema",
+  "ViewEntry",
+  "ViewValue",
+  "Zero",
+  "ZeroEnum",
+  "ZeroObjectReader",
+  "ZeroObjectWriter",
+  "ZeroRow",
+  "ZeroSchema",
+  "ZeroValue",
+  "ZeroValueError",
+  "Array",
+  "Bool",
+  "Dictionary",
+  "Double",
+  "Int",
+  "Optional",
+  "Set",
+  "String"
+]);
+var swiftKeywords = new Set(
+  "associatedtype borrowing class consuming deinit enum extension fileprivate func import init inout internal let nonisolated open operator package private precedencegroup protocol public rethrows static struct subscript typealias var break case catch continue default defer do else fallthrough for guard if in repeat return throw switch where while Any as await false is nil self Self super throws true try".split(" ")
+);
+var nonIdentifierChars = /[^A-Za-z0-9_]/g;
+var leadingDigit = /^[0-9]/;
+var wordBoundary = /([a-z0-9])([A-Z])/g;
+var wordSeparators = /[^A-Za-z0-9]+/;
+var identifierStart = /^[A-Za-z_]/;
+function identifier(name) {
+  let id = name.replace(nonIdentifierChars, "_");
+  if (leadingDigit.test(id) || id === "") {
+    id = "_" + id;
+  }
+  return swiftKeywords.has(id) ? "`" + id + "`" : id;
+}
+function words(name) {
+  return name.replace(wordBoundary, "$1 $2").split(wordSeparators).filter((w) => w !== "");
+}
+function pascalCase(name) {
+  const out = words(name).map((w) => w[0].toUpperCase() + w.slice(1)).join("");
+  return identifierStart.test(out) ? out : "_" + out;
+}
+function camelCase(name) {
+  const p = pascalCase(name);
+  return p[0] === "_" ? p : p[0].toLowerCase() + p.slice(1);
+}
+function str(s) {
+  return JSON.stringify(s);
+}
+function strings(a) {
+  return `[${a.map(str).join(", ")}]`;
+}
+var Emitter = class {
+  #access;
+  #named = [];
+  #names = /* @__PURE__ */ new Set();
+  /** Declared types by alias and shape, so a type used twice is one type. */
+  #byAlias = /* @__PURE__ */ new Map();
+  #prefix;
+  constructor(access, prefix, rowNames) {
+    this.#access = access === "internal" ? "" : "public ";
+    this.#prefix = prefix;
+    for (const n of rowNames) {
+      this.#names.add(n);
+    }
+  }
+  get access() {
+    return this.#access;
+  }
+  bare(name) {
+    return this.#prefix && name.startsWith(this.#prefix) ? name.slice(this.#prefix.length) : name;
+  }
+  get named() {
+    return this.#named;
+  }
+  /** A free type name, without the prefix: the alias, else `fallback`. */
+  #claimBare(preferred, fallback) {
+    const free = (name) => !this.#names.has(this.#prefix + name) && !reservedTypeNames.has(this.#prefix + name);
+    for (const name of [preferred, fallback]) {
+      if (name && free(name)) {
+        this.#names.add(this.#prefix + name);
+        return name;
+      }
+    }
+    for (let i = 2; ; i++) {
+      const name = `${fallback}${i}`;
+      if (free(name)) {
+        this.#names.add(this.#prefix + name);
+        return name;
+      }
+    }
+  }
+  /** The Swift type of a model, naming its enums and objects after `path`. */
+  swiftType(model2, path) {
+    switch (model2.kind) {
+      case "string":
+        return "String";
+      case "number":
+        return "Double";
+      case "boolean":
+        return "Bool";
+      case "json":
+        return "JSONValue";
+      case "nullable":
+        return `${this.swiftType(model2.wrapped, path)}?`;
+      case "array":
+        return `[${this.swiftType(model2.element, path)}]`;
+      case "enum":
+      case "object": {
+        const key = model2.alias && `${model2.alias}:${JSON.stringify(model2)}`;
+        const existing = key && this.#byAlias.get(key);
+        if (existing) {
+          return existing;
+        }
+        const name = this.#prefix + this.#claimBare(model2.alias, path);
+        if (key) {
+          this.#byAlias.set(key, name);
+        }
+        this.#named.push(
+          model2.kind === "enum" ? { kind: "enum", name, cases: model2.cases } : { kind: "object", name, fields: model2.fields }
+        );
+        return name;
+      }
+    }
+  }
+};
+function generate(schema, customTypes, config, source) {
+  const tableNames = Object.keys(schema.tables);
+  const prefix = config.typePrefix ?? "";
+  const rowNames = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const t of tableNames) {
+    let name = config.tables?.[t]?.type ?? prefix + pascalCase(t);
+    if (reservedTypeNames.has(name) || used.has(name)) {
+      name += "Row";
+    }
+    used.add(name);
+    rowNames.set(t, name);
+  }
+  const e = new Emitter(config.access ?? "public", prefix, used);
+  const bare = (name) => prefix && name.startsWith(prefix) ? name.slice(prefix.length) : name;
+  const pub = e.access;
+  const schemaName = config.schemaName ?? "app";
+  const zqlName = config.zql ?? "zql";
+  const zqlType = zqlName === "zql" ? "ZQL" : pascalCase(zqlName);
+  const out = [
+    `// Generated by \`zero-swift codegen\` from ${source}. Do not edit.`,
+    "// swift-format-ignore-file",
+    "",
+    "import Zero",
+    ""
+  ];
+  const typeDecls = [];
+  for (const t of tableNames) {
+    const table = schema.tables[t];
+    const row = rowNames.get(t);
+    const columns = Object.entries(table.columns).map(([name, c]) => {
+      const custom = customTypes.get(t)?.get(name);
+      const override = config.tables?.[t]?.columns?.[name]?.type;
+      let base;
+      if (override === "int") {
+        base = "Int";
+      } else if (c.type === "number" || override === "double") {
+        base = "Double";
+      } else if (c.type === "boolean") {
+        base = "Bool";
+      } else if (c.type === "string") {
+        base = custom?.kind === "enum" ? e.swiftType(custom, bare(row) + pascalCase(name)) : "String";
+      } else if (c.type === "json") {
+        base = custom ? e.swiftType(custom, bare(row) + pascalCase(name)) : "JSONValue";
+      } else {
+        base = "JSONValue";
+      }
+      const optional = c.optional === true;
+      const swiftType = optional && !base.endsWith("?") ? base + "?" : base;
+      return { name, property: identifier(name), swiftType, optional };
+    });
+    const relationships = Object.entries(schema.relationships[t] ?? {}).map(
+      ([name, hops]) => {
+        const last = hops.at(-1);
+        const dest = rowNames.get(last.destSchema);
+        return {
+          name,
+          property: identifier(name),
+          dest,
+          one: last.cardinality === "one"
+        };
+      }
+    );
+    const identifiable = table.primaryKey.length === 1 && table.primaryKey[0] === "id" && columns.some((c) => c.name === "id" && !c.optional);
+    const conformances = ["ZeroRow", "Codable", "Hashable"];
+    if (identifiable) {
+      conformances.push("Identifiable");
+    }
+    const lines = [];
+    lines.push(`${pub}struct ${row}: ${conformances.join(", ")} {`);
+    for (const c of columns) {
+      lines.push(`  ${pub}var ${c.property}: ${c.swiftType}`);
+    }
+    if (relationships.length) {
+      lines.push("");
+      lines.push(
+        "  // Relationships, filled when a query asks for them with `related`."
+      );
+      for (const r of relationships) {
+        lines.push(
+          r.one ? `  @Indirect ${pub}var ${r.property}: ${r.dest}?` : `  ${pub}var ${r.property}: [${r.dest}]?`
+        );
+      }
+    }
+    const params = [
+      ...columns.map(
+        (c) => `${c.property}: ${c.swiftType}${c.optional ? " = nil" : ""}`
+      ),
+      ...relationships.map(
+        (r) => `${r.property}: ${r.one ? `${r.dest}?` : `[${r.dest}]?`} = nil`
+      )
+    ];
+    lines.push("");
+    lines.push(`  ${pub}init(`);
+    lines.push(params.map((p) => `    ${p}`).join(",\n"));
+    lines.push("  ) {");
+    for (const c of [...columns, ...relationships]) {
+      lines.push(`    self.${c.property} = ${c.property}`);
+    }
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  ${pub}static let tableName = ${str(t)}`);
+    lines.push("");
+    lines.push(`  ${pub}static let columns: KeyPathNames<${row}> = [`);
+    for (const c of columns) {
+      lines.push(`    \\${row}.${c.property}: ${str(c.name)},`);
+    }
+    lines.push("  ]");
+    lines.push("");
+    lines.push(
+      `  ${pub}static let relationships: KeyPathNames<${row}> = ${relationships.length ? "[" : "[:]"}`
+    );
+    if (relationships.length) {
+      for (const r of relationships) {
+        lines.push(`    \\${row}.${r.property}: ${str(r.name)},`);
+      }
+      lines.push("  ]");
+    }
+    lines.push("");
+    lines.push(`  ${pub}init(entry: ViewEntry) throws(ZeroValueError) {`);
+    for (const [i, c] of columns.entries()) {
+      lines.push(`    ${c.property} = try entry.column(${str(c.name)}, ${i})`);
+    }
+    for (const r of relationships) {
+      lines.push(`    ${r.property} = try entry.relationship(${str(r.name)})`);
+    }
+    lines.push("  }");
+    lines.push("");
+    lines.push(`  ${pub}var columnValues: Row {`);
+    lines.push("    [");
+    for (const c of columns) {
+      lines.push(`      ${str(c.name)}: ${c.property}.zeroValue,`);
+    }
+    lines.push("    ]");
+    lines.push("  }");
+    lines.push("}");
+    typeDecls.push(lines.join("\n"));
+  }
+  const namedDecls = [];
+  for (let i = 0; i < e.named.length; i++) {
+    const n = e.named[i];
+    namedDecls.push(
+      n.kind === "enum" ? enumDecl(pub, n) : objectDecl(e, pub, n)
+    );
+  }
+  out.push(...typeDecls.flatMap((d) => [d, ""]));
+  out.push(...namedDecls.flatMap((d) => [d, ""]));
+  out.push(schemaDecl(pub, schema, schemaName));
+  out.push("");
+  out.push(
+    `/// The queries of \`ZeroSchema.${schemaName}\`, one per table: \`${zqlName}.${tableNames[0] ?? "table"}.where(\u2026)\`.`
+  );
+  out.push(`${pub}struct ${zqlType}: Sendable {`);
+  out.push(`  ${pub}init() {}`);
+  for (const t of tableNames) {
+    const row = rowNames.get(t);
+    out.push("");
+    out.push(
+      `  ${pub}var ${identifier(t)}: Query<${row}, [${row}]> { Query(AnyQuery(.${schemaName}, ${str(t)})) }`
+    );
+  }
+  out.push("}");
+  out.push("");
+  out.push(`${pub}let ${identifier(zqlName)} = ${zqlType}()`);
+  out.push("");
+  return out.join("\n");
+}
+function enumDecl(pub, n) {
+  const used = /* @__PURE__ */ new Set();
+  const lines = [
+    `${pub}enum ${n.name}: String, ZeroEnum, Codable, CaseIterable {`
+  ];
+  for (const value of n.cases) {
+    let c = camelCase(value);
+    while (used.has(c)) {
+      c += "_";
+    }
+    used.add(c);
+    const id = identifier(c);
+    lines.push(c === value ? `  case ${id}` : `  case ${id} = ${str(value)}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function objectDecl(e, pub, n) {
+  const fields = n.fields.map((f) => {
+    const base = e.swiftType(f.type, e.bare(n.name) + pascalCase(f.name));
+    const type = f.optional && !base.endsWith("?") ? base + "?" : base;
+    return { ...f, property: identifier(f.name), swiftType: type };
+  });
+  const lines = [`${pub}struct ${n.name}: ZeroValue, Codable, Hashable {`];
+  for (const f of fields) {
+    lines.push(`  ${pub}var ${f.property}: ${f.swiftType}`);
+  }
+  lines.push("");
+  lines.push(`  ${pub}init(`);
+  lines.push(
+    fields.map(
+      (f) => `    ${f.property}: ${f.swiftType}${f.swiftType.endsWith("?") ? " = nil" : ""}`
+    ).join(",\n")
+  );
+  lines.push("  ) {");
+  for (const f of fields) {
+    lines.push(`    self.${f.property} = ${f.property}`);
+  }
+  lines.push("  }");
+  lines.push("");
+  lines.push(`  ${pub}init(zeroValue: JSONValue) throws(ZeroValueError) {`);
+  lines.push(`    let o = try ZeroObjectReader(zeroValue, ${str(n.name)})`);
+  for (const f of fields) {
+    lines.push(`    ${f.property} = try o.field(${str(f.name)})`);
+  }
+  lines.push("  }");
+  lines.push("");
+  lines.push(`  ${pub}var zeroValue: JSONValue {`);
+  lines.push("    var o = ZeroObjectWriter()");
+  for (const f of fields) {
+    lines.push(
+      f.optional ? `    o.setIfPresent(${str(f.name)}, ${f.property})` : `    o.set(${str(f.name)}, ${f.property})`
+    );
+  }
+  lines.push("    return o.value");
+  lines.push("  }");
+  lines.push("}");
+  return lines.join("\n");
+}
+function schemaDecl(pub, schema, name) {
+  const lines = ["extension ZeroSchema {"];
+  lines.push(`  ${pub}static let ${identifier(name)} = ZeroSchema(`);
+  lines.push("    tables: [");
+  for (const [t, table] of Object.entries(schema.tables)) {
+    lines.push("      TableSchema(");
+    lines.push(
+      `        name: ${str(t)},${table.serverName ? ` serverName: ${str(table.serverName)},` : ""}`
+    );
+    lines.push("        columns: [");
+    for (const [c, col] of Object.entries(table.columns)) {
+      const args = [`.${col.type}`];
+      if (col.optional) args.push("optional: true");
+      if (col.serverName) args.push(`serverName: ${str(col.serverName)}`);
+      lines.push(`          (${str(c)}, ColumnSchema(${args.join(", ")})),`);
+    }
+    lines.push("        ],");
+    const keys = table.uniqueKeys?.length ? `,
+        uniqueKeys: [${table.uniqueKeys.map(strings).join(", ")}]` : "";
+    lines.push(`        primaryKey: ${strings(table.primaryKey)}${keys}),`);
+  }
+  lines.push("    ],");
+  const rels = Object.entries(schema.relationships).filter(
+    ([, r]) => Object.keys(r).length > 0
+  );
+  if (rels.length === 0) {
+    lines.push("    relationships: [:])");
+  } else {
+    lines.push("    relationships: [");
+    for (const [t, byName] of rels) {
+      lines.push(`      ${str(t)}: [`);
+      for (const [r, hops] of Object.entries(byName)) {
+        lines.push(`        ${str(r)}: [`);
+        for (const h of hops) {
+          lines.push(
+            `          RelationshipHop(sourceField: ${strings(h.sourceField)}, destField: ${strings(h.destField)}, destSchema: ${str(h.destSchema)}, cardinality: .${h.cardinality}),`
+          );
+        }
+        lines.push("        ],");
+      }
+      lines.push("      ],");
+    }
+    lines.push("    ])");
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/types.ts
+import { dirname, resolve } from "node:path";
+import ts from "typescript";
+var defaultOptions = {
+  target: ts.ScriptTarget.ES2022,
+  module: ts.ModuleKind.NodeNext,
+  moduleResolution: ts.ModuleResolutionKind.NodeNext,
+  allowImportingTsExtensions: true,
+  strict: true,
+  noEmit: true,
+  skipLibCheck: true
+};
+function readCustomTypes(schemaPath, exportName) {
+  const file = resolve(schemaPath);
+  const program = ts.createProgram([file], compilerOptions(file));
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(file);
+  const module = source && checker.getSymbolAtLocation(source);
+  if (!module) {
+    throw new Error(`Cannot read the types of ${schemaPath}`);
+  }
+  let symbol = checker.getExportsOfModule(module).find((s) => s.name === exportName);
+  if (!symbol) {
+    throw new Error(`${schemaPath} does not export "${exportName}"`);
+  }
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  const schemaType = checker.getTypeOfSymbol(symbol);
+  const out = /* @__PURE__ */ new Map();
+  const tables = property(checker, schemaType, "tables");
+  for (const table of tables ? checker.getPropertiesOfType(tables) : []) {
+    const columns = property(
+      checker,
+      checker.getTypeOfSymbol(table),
+      "columns"
+    );
+    const byColumn = /* @__PURE__ */ new Map();
+    for (const column of columns ? checker.getPropertiesOfType(columns) : []) {
+      const custom = property(
+        checker,
+        checker.getTypeOfSymbol(column),
+        "customType"
+      );
+      if (custom) {
+        byColumn.set(column.name, model(checker, custom));
+      }
+    }
+    out.set(table.name, byColumn);
+  }
+  return out;
+}
+function compilerOptions(file) {
+  const configPath = ts.findConfigFile(dirname(file), ts.sys.fileExists);
+  if (!configPath) {
+    return defaultOptions;
+  }
+  const parsed = ts.getParsedCommandLineOfConfigFile(configPath, void 0, {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: () => {
+    }
+  });
+  return parsed ? { ...parsed.options, noEmit: true, skipLibCheck: true } : defaultOptions;
+}
+function property(checker, type, name) {
+  const p = checker.getPropertyOfType(type, name);
+  return p && checker.getTypeOfSymbol(p);
+}
+var nullish = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+function model(checker, type) {
+  const alias = aliasName(type);
+  if (type.isUnion()) {
+    const parts = type.types.filter((t) => !(t.flags & nullish));
+    const nullable = parts.length !== type.types.length;
+    const inner = unionModel(checker, parts, alias);
+    return nullable ? { kind: "nullable", wrapped: inner } : inner;
+  }
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      if (t.flags & ts.TypeFlags.StringLike) return { kind: "string" };
+      if (t.flags & ts.TypeFlags.NumberLike) return { kind: "number" };
+    }
+    return { kind: "json" };
+  }
+  if (type.isStringLiteral()) {
+    return enumModel([type.value], alias);
+  }
+  if (type.flags & ts.TypeFlags.StringLike) return { kind: "string" };
+  if (type.flags & ts.TypeFlags.NumberLike) return { kind: "number" };
+  if (type.flags & ts.TypeFlags.BooleanLike) return { kind: "boolean" };
+  if (checker.isArrayType(type)) {
+    const [element] = checker.getTypeArguments(type);
+    return {
+      kind: "array",
+      element: element ? model(checker, element) : { kind: "json" }
+    };
+  }
+  if (type.flags & ts.TypeFlags.Object && isPlainObject(checker, type)) {
+    const fields = checker.getPropertiesOfType(type).map((p) => {
+      const optional = (p.flags & ts.SymbolFlags.Optional) !== 0;
+      let t = checker.getTypeOfSymbol(p);
+      if (optional) {
+        t = checker.getNonNullableType(t);
+      }
+      return { name: p.name, type: model(checker, t), optional };
+    });
+    return { kind: "object", ...alias ? { alias } : {}, fields };
+  }
+  return { kind: "json" };
+}
+function unionModel(checker, parts, alias) {
+  if (parts.length === 0) return { kind: "json" };
+  if (parts.every((t) => t.isStringLiteral())) {
+    return enumModel(
+      parts.map((t) => t.value),
+      alias
+    );
+  }
+  if (parts.every((t) => t.flags & ts.TypeFlags.BooleanLike)) {
+    return { kind: "boolean" };
+  }
+  if (parts.every((t) => t.flags & ts.TypeFlags.NumberLike)) {
+    return { kind: "number" };
+  }
+  if (parts.length === 1) return model(checker, parts[0]);
+  return { kind: "json" };
+}
+function enumModel(cases, alias) {
+  return { kind: "enum", ...alias ? { alias } : {}, cases };
+}
+function isPlainObject(checker, type) {
+  return checker.getPropertiesOfType(type).length > 0 && type.getCallSignatures().length === 0 && type.getConstructSignatures().length === 0 && checker.getIndexInfosOfType(type).length === 0;
+}
+function aliasName(type) {
+  if (type.aliasSymbol && !type.aliasTypeArguments?.length) {
+    return type.aliasSymbol.name;
+  }
+  const name = type.getSymbol()?.name;
+  if (name && !name.startsWith("__") && type.flags & ts.TypeFlags.Object && (type.getSymbol().flags & ts.SymbolFlags.Interface) !== 0) {
+    return name;
+  }
+  return void 0;
+}
+
+// src/cli.ts
+async function codegenFile(config, cwd) {
+  const schemaPath = resolve2(cwd, config.schema ?? "schema.ts");
+  const exportName = config.export ?? "schema";
+  const module = await import(pathToFileURL(schemaPath).href);
+  const schema = module[exportName];
+  if (!schema || typeof schema !== "object" || !("tables" in schema)) {
+    throw new Error(
+      `${schemaPath} does not export a schema as "${exportName}"`
+    );
+  }
+  const customTypes = readCustomTypes(schemaPath, exportName);
+  return generate(
+    schema,
+    customTypes,
+    config,
+    relative(cwd, schemaPath).replaceAll("\\", "/")
+  );
+}
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      schema: { type: "string" },
+      out: { type: "string" },
+      config: { type: "string" },
+      samples: { type: "string" },
+      check: { type: "boolean" }
+    }
+  });
+  const [command = "codegen", subcommand] = positionals;
+  const cwd = process.cwd();
+  if (command === "drift" && subcommand === "record") {
+    const { recordDriftFile } = await import("./drift-S756Q2ZA.js");
+    const vectors = await recordDriftFile(
+      resolve2(cwd, values.samples ?? "drift-samples.ts")
+    );
+    return writeOutput(
+      resolve2(cwd, values.out ?? "drift-vectors.json"),
+      vectors,
+      values.check ?? false,
+      cwd
+    );
+  }
+  if (command !== "codegen") {
+    process.stderr.write(`Unknown command "${positionals.join(" ")}"
+`);
+    return 2;
+  }
+  const configPath = values.config ?? (existsSync(resolve2(cwd, "zero-swift.json")) ? "zero-swift.json" : void 0);
+  const fileConfig = configPath ? JSON.parse(readFileSync(resolve2(cwd, configPath), "utf8")) : {};
+  const config = {
+    ...fileConfig,
+    ...values.schema ? { schema: values.schema } : {},
+    ...values.out ? { output: values.out } : {}
+  };
+  const output = resolve2(cwd, config.output ?? "Schema.swift");
+  const swift = await codegenFile(config, cwd);
+  return writeOutput(output, swift, values.check ?? false, cwd);
+}
+function writeOutput(output, contents, check, cwd) {
+  const current = existsSync(output) ? readFileSync(output, "utf8") : void 0;
+  if (check) {
+    if (current !== contents) {
+      process.stderr.write(`${relative(cwd, output)} is out of date
+`);
+      return 1;
+    }
+    return 0;
+  }
+  if (current !== contents) {
+    writeFileSync(output, contents);
+  }
+  process.stdout.write(`Wrote ${relative(cwd, output)}
+`);
+  return 0;
+}
+
+// src/bin.ts
+process.exitCode = await main(process.argv.slice(2));