zero-swift 0.3.0 → 0.4.1

package/README.md

@@ -55,6 +55,29 @@ Rename a row struct whose name clashes with a type you use. A table named
 `list` generates `struct List`, which hides SwiftUI's `List`; set
 `tables.list.type` to `NoteList`, or set a `typePrefix`.
 
+### Names
+
+Tables, columns, relationships, JSON fields and enumeration values keep
+their names where Swift allows them, and keywords are backticked. Otherwise:
+
+- Characters Swift doesn't allow in identifiers become `_` (`a-b` is
+  `a_b`), and a leading digit gets a `_`. A name with none it allows is `_`
+  and its code points in hex: the enumeration value `+` is `_2B`.
+- A member that is taken, that the generated code declares (such as
+  `columnValues`, `hashValue`, `zeroValue` or `rawValue`), or that Swift
+  doesn't allow even backticked (`self`, `Type`, `Protocol`) gets `_`
+  appended until it is free: `self_`. Names that need no change are claimed
+  first, so with columns `a-b` and `a_b`, `a_b` keeps its name and `a-b` is
+  `a_b_`.
+- A row struct name that is a keyword, taken, or a type the generated code
+  uses (such as `Zero`, `ZeroRow` or `Codable`) gets `Row`, then a number
+  from 2: `zero` is `ZeroRow2`.
+
+A renamed member still reads and writes the original name: the column
+names, `CodingKeys`, and enumeration raw values use it.
+
+A recursive `json<T>()` type is `JSONValue` where it recurs.
+
 Each config key has an option, such as `--schema-file`, `--out`,
 `--type-prefix`, and `--access`, that overrides it. `--config` picks the
 config file. Run `npx zero-swift codegen --help` for the full list.

package/dist/bin.js

@@ -9,7 +9,7 @@ import { Cli, z } from "incur";
 // package.json
 var package_default = {
   name: "zero-swift",
-  version: "0.3.0",
+  version: "0.4.1",
   description: "Generates the Swift row types and schema of a Zero app for the Zero Swift client.",
   license: "Apache-2.0",
   repository: {
@@ -95,36 +95,221 @@ var reservedTypeNames = /* @__PURE__ */ new Set([
   "Int",
   "Optional",
   "Set",
-  "String"
+  "String",
+  // The protocols the generated types conform to, and the types of their
+  // members.
+  "AllCases",
+  "CaseIterable",
+  "Codable",
+  "CodingKey",
+  "CodingKeys",
+  "Decodable",
+  "Encodable",
+  "Equatable",
+  "Hashable",
+  "Hasher",
+  "Identifiable",
+  "KeyPath",
+  "PartialKeyPath",
+  "RawRepresentable",
+  "RawValue",
+  "Sendable"
 ]);
 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(" ")
+  "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 unusableMembers = /* @__PURE__ */ new Set(["self", "Type", "Protocol"]);
+var rowMembers = [
+  "tableName",
+  "columns",
+  "relationships",
+  "columnValues",
+  "hashValue",
+  "CodingKeys",
+  // The parameter of `init(entry:)`, which assigns the columns.
+  "entry"
+];
+var objectMembers = [
+  "zeroValue",
+  "valueForNull",
+  "hashValue",
+  "CodingKeys",
+  // The local of `init(zeroValue:)` and `zeroValue`, which use the fields.
+  "o"
+];
+var enumMembers = [
+  "rawValue",
+  "RawValue",
+  "zeroValue",
+  "valueForNull",
+  "allCases",
+  "AllCases"
+];
+var asciiIdentifierChar = /[A-Za-z0-9_]/;
+var unicodeIdentifierChar = /[\p{L}\p{M}\p{N}]/u;
 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;
+var identifierRanges = [
+  [168, 168],
+  [170, 170],
+  [173, 173],
+  [175, 175],
+  [178, 181],
+  [183, 186],
+  [188, 190],
+  [192, 214],
+  [216, 246],
+  [248, 767],
+  [768, 879],
+  [880, 5759],
+  [5761, 6157],
+  [6159, 7615],
+  [7616, 7679],
+  [7680, 8191],
+  [8304, 8591],
+  [9312, 9471],
+  [10102, 10131],
+  [11264, 11775],
+  [11904, 12287],
+  [12292, 12295],
+  [12321, 12335],
+  [12337, 12351],
+  [12352, 55295],
+  [63744, 64829],
+  [64832, 64975],
+  [65008, 65055],
+  [65056, 65071],
+  [65072, 65092],
+  [65095, 65533],
+  [65536, 983037]
+];
+var nonHeadRanges = [
+  [48, 57],
+  [768, 879],
+  [7616, 7679],
+  [8400, 8447],
+  [65056, 65071]
+];
+var inRanges = (c, ranges) => ranges.some(([lo, hi]) => c >= lo && c <= hi);
+function isIdentifierChar(ch) {
+  const c = ch.codePointAt(0);
+  return c < 128 ? asciiIdentifierChar.test(ch) : unicodeIdentifierChar.test(ch) && inRanges(c, identifierRanges);
+}
+function isIdentifierHead(ch) {
+  return isIdentifierChar(ch) && !inRanges(ch.codePointAt(0), nonHeadRanges);
+}
+function sanitize(name) {
+  const chars = [...name];
+  if (!chars.some(isIdentifierChar)) {
+    return chars.length ? "_" + chars.map((ch) => ch.codePointAt(0).toString(16).toUpperCase()).join("_") : "_";
   }
+  const id = chars.map((ch) => isIdentifierChar(ch) ? ch : "_");
+  return (isIdentifierHead(id[0]) ? "" : "_") + id.join("");
+}
+function ref(id) {
   return swiftKeywords.has(id) ? "`" + id + "`" : id;
 }
+function identifier(name) {
+  return ref(sanitize(name));
+}
+var Members = class {
+  #used;
+  constructor(reserved = []) {
+    this.#used = new Set(reserved);
+  }
+  #free(id) {
+    return !this.#used.has(id) && !unusableMembers.has(id);
+  }
+  #available(id, wrapped) {
+    return this.#free(id) && (!wrapped || this.#free("_" + id));
+  }
+  /**
+   * A free member for `id`, not backticked. `wrapped` also claims the
+   * `_id` storage of a property wrapper.
+   */
+  claim(id, wrapped = false) {
+    while (!this.#available(id, wrapped)) {
+      id += "_";
+    }
+    this.#used.add(id);
+    if (wrapped) {
+      this.#used.add("_" + id);
+    }
+    return id;
+  }
+  /**
+   * Claims a member for each name, from `id`, its identifier. The names
+   * that are their identifier and free claim first, so a name that works
+   * as it is keeps it.
+   */
+  claimAll(names) {
+    const out = [];
+    const keep = names.map(
+      (n) => n.id === n.name && this.#available(n.id, n.wrapped ?? false)
+    );
+    for (const pass of [true, false]) {
+      for (const [i, n] of names.entries()) {
+        if (keep[i] === pass) {
+          out[i] = this.claim(n.id, n.wrapped);
+        }
+      }
+    }
+    return out;
+  }
+};
 function words(name) {
-  return name.replace(wordBoundary, "$1 $2").split(wordSeparators).filter((w) => w !== "");
+  const out = [];
+  let word = "";
+  for (const ch of name.replace(wordBoundary, "$1 $2")) {
+    if (ch !== "_" && isIdentifierChar(ch)) {
+      word += ch;
+    } else if (word) {
+      out.push(word);
+      word = "";
+    }
+  }
+  return word ? [...out, word] : out;
+}
+function capitalize(w) {
+  const [first, ...rest] = w;
+  return first.toUpperCase() + rest.join("");
 }
 function pascalCase(name) {
-  const out = words(name).map((w) => w[0].toUpperCase() + w.slice(1)).join("");
-  return identifierStart.test(out) ? out : "_" + out;
+  const out = words(name).map(capitalize).join("");
+  if (out === "") {
+    return sanitize(name);
+  }
+  return isIdentifierHead([...out][0]) ? out : "_" + out;
 }
 function camelCase(name) {
   const p = pascalCase(name);
-  return p[0] === "_" ? p : p[0].toLowerCase() + p.slice(1);
+  if (p[0] === "_") {
+    return p;
+  }
+  const [first, ...rest] = p;
+  return first.toLowerCase() + rest.join("");
 }
 function str(s) {
-  return JSON.stringify(s);
+  let out = '"';
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    if (ch === '"' || ch === "\\") {
+      out += "\\" + ch;
+    } else if (ch === "\n") {
+      out += "\\n";
+    } else if (ch === "\r") {
+      out += "\\r";
+    } else if (ch === "	") {
+      out += "\\t";
+    } else if (c < 32 || c === 127 || c >= 55296 && c <= 57343) {
+      out += `\\u{${(c >= 55296 && c <= 57343 ? 65533 : c).toString(16)}}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out + '"';
+}
+function typeTaken(name, used) {
+  return used.has(name) || reservedTypeNames.has(name) || swiftKeywords.has(name);
 }
 function strings(a) {
   return `[${a.map(str).join(", ")}]`;
@@ -152,9 +337,13 @@ var Emitter = class {
   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);
+  /**
+   * A free type name, without the prefix: the alias, else `path` as an
+   * identifier, else that with a number.
+   */
+  #claimBare(preferred, path) {
+    const fallback = sanitize(path);
+    const free = (name) => sanitize(name) === name && !typeTaken(this.#prefix + name, this.#names);
     for (const name of [preferred, fallback]) {
       if (name && free(name)) {
         this.#names.add(this.#prefix + name);
@@ -206,12 +395,16 @@ var Emitter = class {
 function generate(schema, customTypes, config, source) {
   const tableNames = Object.keys(schema.tables);
   const prefix = config.typePrefix ?? "";
+  const schemaName = config.schemaName ?? "app";
+  const zqlName = config.zql ?? "zql";
+  const zqlType = zqlName === "zql" ? "ZQL" : pascalCase(zqlName);
   const rowNames = /* @__PURE__ */ new Map();
-  const used = /* @__PURE__ */ new Set();
+  const used = /* @__PURE__ */ new Set([zqlType]);
   for (const t of tableNames) {
-    let name = config.tables?.[t]?.type ?? prefix + pascalCase(t);
-    if (reservedTypeNames.has(name) || used.has(name)) {
-      name += "Row";
+    const preferred = config.tables?.[t]?.type ?? prefix + pascalCase(t);
+    let name = preferred;
+    for (let i = 1; typeTaken(name, used); i++) {
+      name = `${preferred}Row${i === 1 ? "" : i}`;
     }
     used.add(name);
     rowNames.set(t, name);
@@ -219,9 +412,6 @@ function generate(schema, customTypes, config, source) {
   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",
@@ -252,21 +442,27 @@ function generate(schema, customTypes, config, source) {
       }
       const optional = c.optional === true;
       const swiftType = optional && !base.endsWith("?") ? base + "?" : base;
-      return { name, property: identifier(name), swiftType, optional };
+      const id = sanitize(name);
+      return { name, id, property: ref(id), 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 one = last.cardinality === "one";
+        const id = sanitize(name);
+        return { name, id, property: ref(id), dest, one };
       }
     );
-    const identifiable = table.primaryKey.length === 1 && table.primaryKey[0] === "id" && columns.some((c) => c.name === "id" && !c.optional);
+    const props = [...columns, ...relationships];
+    const ids = new Members(rowMembers).claimAll(
+      props.map((p) => ({ ...p, wrapped: "one" in p && p.one }))
+    );
+    for (const [i, p] of props.entries()) {
+      p.id = ids[i];
+      p.property = ref(ids[i]);
+    }
+    const identifiable = table.primaryKey.length === 1 && table.primaryKey[0] === "id" && columns.some((c) => c.name === "id" && c.id === "id" && !c.optional);
     const conformances = ["ZeroRow", "Codable", "Hashable"];
     if (identifiable) {
       conformances.push("Identifiable");
@@ -338,6 +534,7 @@ function generate(schema, customTypes, config, source) {
     }
     lines.push("    ]");
     lines.push("  }");
+    lines.push(...codingKeys([...columns, ...relationships]));
     lines.push("}");
     typeDecls.push(lines.join("\n"));
   }
@@ -357,11 +554,14 @@ function generate(schema, customTypes, config, source) {
   );
   out.push(`${pub}struct ${zqlType}: Sendable {`);
   out.push(`  ${pub}init() {}`);
-  for (const t of tableNames) {
+  const tableIds = new Members().claimAll(
+    tableNames.map((t) => ({ name: t, id: sanitize(t) }))
+  );
+  for (const [i, t] of tableNames.entries()) {
     const row = rowNames.get(t);
     out.push("");
     out.push(
-      `  ${pub}var ${identifier(t)}: Query<${row}, [${row}]> { Query(AnyQuery(.${schemaName}, ${str(t)})) }`
+      `  ${pub}var ${ref(tableIds[i])}: Query<${row}, [${row}]> { Query(AnyQuery(.${schemaName}, ${str(t)})) }`
     );
   }
   out.push("}");
@@ -370,28 +570,43 @@ function generate(schema, customTypes, config, source) {
   out.push("");
   return out.join("\n");
 }
+function codingKeys(props) {
+  if (props.every((p) => p.id === p.name)) {
+    return [];
+  }
+  return [
+    "",
+    "  private enum CodingKeys: String, CodingKey {",
+    ...props.map(
+      (p) => p.id === p.name ? `    case ${p.property}` : `    case ${p.property} = ${str(p.name)}`
+    ),
+    "  }"
+  ];
+}
 function enumDecl(pub, n) {
-  const used = /* @__PURE__ */ new Set();
+  const ids = new Members(enumMembers).claimAll(
+    n.cases.map((value) => ({ name: value, id: camelCase(value) }))
+  );
   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)}`);
+  for (const [i, value] of n.cases.entries()) {
+    const c = ids[i];
+    lines.push(
+      c === value ? `  case ${ref(c)}` : `  case ${ref(c)} = ${str(value)}`
+    );
   }
   lines.push("}");
   return lines.join("\n");
 }
 function objectDecl(e, pub, n) {
-  const fields = n.fields.map((f) => {
+  const ids = new Members(objectMembers).claimAll(
+    n.fields.map((f) => ({ name: f.name, id: sanitize(f.name) }))
+  );
+  const fields = n.fields.map((f, i) => {
     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 };
+    return { ...f, id: ids[i], property: ref(ids[i]), swiftType: type };
   });
   const lines = [`${pub}struct ${n.name}: ZeroValue, Codable, Hashable {`];
   for (const f of fields) {
@@ -426,6 +641,7 @@ function objectDecl(e, pub, n) {
   }
   lines.push("    return o.value");
   lines.push("  }");
+  lines.push(...codingKeys(fields));
   lines.push("}");
   return lines.join("\n");
 }
@@ -545,13 +761,17 @@ function property(checker, type, name) {
   const p = checker.getPropertyOfType(type, name);
   return p && checker.getTypeOfSymbol(p);
 }
+var maxDepth = 32;
 var nullish = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
-function model(checker, type) {
+function model(checker, type, outer = /* @__PURE__ */ new Set()) {
+  if (outer.has(type) || outer.size >= maxDepth) {
+    return { kind: "json" };
+  }
   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);
+    const inner = unionModel(checker, parts, alias, outer);
     return nullable ? { kind: "nullable", wrapped: inner } : inner;
   }
   if (type.isIntersection()) {
@@ -571,23 +791,24 @@ function model(checker, type) {
     const [element] = checker.getTypeArguments(type);
     return {
       kind: "array",
-      element: element ? model(checker, element) : { kind: "json" }
+      element: element ? model(checker, element, outer) : { kind: "json" }
     };
   }
   if (type.flags & ts.TypeFlags.Object && isPlainObject(checker, type)) {
+    const inside = new Set(outer).add(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 { name: p.name, type: model(checker, t, inside), optional };
     });
     return { kind: "object", ...alias ? { alias } : {}, fields };
   }
   return { kind: "json" };
 }
-function unionModel(checker, parts, alias) {
+function unionModel(checker, parts, alias, outer) {
   if (parts.length === 0) return { kind: "json" };
   if (parts.every((t) => t.isStringLiteral())) {
     return enumModel(
@@ -601,7 +822,7 @@ function unionModel(checker, parts, alias) {
   if (parts.every((t) => t.flags & ts.TypeFlags.NumberLike)) {
     return { kind: "number" };
   }
-  if (parts.length === 1) return model(checker, parts[0]);
+  if (parts.length === 1) return model(checker, parts[0], outer);
   return { kind: "json" };
 }
 function enumModel(cases, alias) {
@@ -707,7 +928,7 @@ var cli = Cli.create("zero-swift", {
   version: package_default.version,
   description: "Generates what the Zero Swift client needs from a Zero app's TypeScript schema, queries, and mutators."
 }).command("codegen", {
-  description: "Generate the Swift row types, schema, and query builder from the app's TypeScript schema. Options override zero-swift.json, which is read when present.",
+  description: "Generate the Swift row types, schema, and query builder from the app's TypeScript schema. Options override zero-swift.json, which is read when present. See swift/Sources/Zero/Zero.docc/GettingStarted.md in github.com/wevm/zero.",
   options: z.object({
     config: z.string().optional().describe("Config file (default zero-swift.json, when present)"),
     schemaFile: z.string().optional().describe("TS schema module (default schema.ts)"),
@@ -719,20 +940,10 @@ var cli = Cli.create("zero-swift", {
     access: z.enum(["public", "internal"]).optional().describe("Access level of the generated code (default public)"),
     check
   }),
-  examples: [
-    { description: "Generate from zero-swift.json" },
-    {
-      options: {
-        schemaFile: "shared/schema.ts",
-        out: "Sources/App/Schema.swift"
-      },
-      description: "Generate without a config file"
-    },
-    {
-      options: { check: true },
-      description: "Fail in CI when the output is stale"
-    }
-  ],
+  // incur 0.7.1 prints example options as `--camelKey value`, so the hint
+  // shows `--schema-file` and a bare `--check` instead.
+  examples: [{ description: "Generate from zero-swift.json" }],
+  hint: "Without a config file: zero-swift codegen --schema-file shared/schema.ts --out Sources/App/Schema.swift. In CI, zero-swift codegen --check fails when the output is stale.",
   run: (c) => reporting(c.error, async () => {
     const cwd = process.cwd();
     const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-swift",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Generates the Swift row types and schema of a Zero app for the Zero Swift client.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,9 +25,9 @@
     "oxfmt": "^0.74.0",
     "vitest": "^5.0.0",
     "@rocicorp/zero": "1.12.0",
+    "zero-schema": "0.0.0",
     "zero-types": "0.0.0",
-    "zql": "0.0.0",
-    "zero-schema": "0.0.0"
+    "zql": "0.0.0"
   },
   "peerDependencies": {
     "@rocicorp/zero": ">=1.11.0"