zitejs 0.9.105 → 0.9.107

package/dist/cjs/api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCaller = void 0;
+var index_js_1 = require("../caller/index.js");
+Object.defineProperty(exports, "createCaller", { enumerable: true, get: function () { return index_js_1.createCaller; } });

package/dist/cjs/db/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTableClient = void 0;
+var index_js_1 = require("../runtime/index.js");
+Object.defineProperty(exports, "createTableClient", { enumerable: true, get: function () { return index_js_1.createTableClient; } });

package/dist/cjs/runtime/index.d.ts

@@ -99,15 +99,37 @@ export interface TableFindAllOptions<T = Record<string, unknown>> {
     filter?: unknown;
     fields?: Array<FieldSelector<T>>;
 }
+/**
+ * Both write results carry the record twice — flat, and again under `fields`.
+ *
+ * That is not a quirk of the type. Both dispatchers build it deliberately, with
+ * the same code and the same comment ("Return both flat fields and nested
+ * fields for backwards compatibility"):
+ * `cloudflare-lambda/src/integrations/databases.ts` and
+ * `workflow-runner/src/sdk/databases.ts`.
+ *
+ * The types said otherwise, each in a different direction — `BulkCreateResult`
+ * declared only the flat form, `UpdateResult` only the nested one. So a 1.0 app
+ * reading `created.fields.token`, which is what 1.0's SDK typed, stopped
+ * compiling after migrating even though the value was sitting right there at
+ * runtime. DSA Employee Portal migrated "successfully" and then would not build.
+ *
+ * Declaring both is the whole fix: nothing about the running code changes, and
+ * no app source has to be rewritten to match a type narrower than what the
+ * runtime actually returns.
+ */
 export interface BulkCreateResult<T> {
     /** Absent when `records: []` was passed — the dispatch short-circuits before setting it. */
     success?: boolean;
-    records: T[];
+    records: Array<T & {
+        fields: T;
+    }>;
 }
-export interface UpdateResult<T> {
+/** A type alias, not an interface: an interface cannot extend a generic `Partial<T>`. */
+export type UpdateResult<T> = Partial<T> & {
     id: string;
     fields: Partial<T>;
-}
+};
 export interface DeleteResult {
     success: true;
     id: string;

package/dist/cjs/runtime/writeResultTypes.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/runtime/writeResultTypes.test-d.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("BulkCreateResult", () => {
+    // The 1.0 spelling. This is the one that regressed.
+    (0, vitest_1.it)("reads through .fields", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    // The 2.0 spelling, which must keep working — apps written since migration
+    // use it, so this is not a case of swapping one shape for the other.
+    (0, vitest_1.it)("reads flat", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    (0, vitest_1.it)("keeps success optional", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+});
+(0, vitest_1.describe)("UpdateResult", () => {
+    // The mirror image: `update` returned `{ ...transformed, fields: transformed }`
+    // but the type declared only `id` and `fields`, so reading a column straight
+    // off an update result failed to compile.
+    (0, vitest_1.it)("reads flat and through .fields", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+});

package/dist/cjs/sync/lib.d.ts

@@ -14,18 +14,7 @@ export type ZiteSchemaTable = {
 export type ZiteSchema = {
     tables: ZiteSchemaTable[];
 };
-export declare function toPascalCase(name: string): string;
-export declare function toCamelCase(name: string): string;
-/**
- * camelCase for a FRESH sdkName, reading acronym runs as words: "VIP" ->
- * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey").
- *
- * Deliberately not folded into toCamelCase: that also derives endpoint
- * identifiers from existing filenames on every generate, where normalizing
- * would rename a working app's `api.sendSMS`. This is only for names being
- * chosen for the first time — generateSchema preserves existing sdkNames.
- */
-export declare function toSdkName(name: string): string;
+export { toPascalCase, toCamelCase, toSdkName } from "./sdkNames.js";
 /**
  * Build a ZiteSchema from a Database API response.
  *
@@ -39,7 +28,7 @@ export declare function generateSchema(database: Database, existingSchema?: Zite
  * Generate .zite/db.ts purely from ZiteSchema.
  * Pure function — no external data needed beyond what's in the schema file.
  */
-export declare function generateDbTs(schema: ZiteSchema): string;
+export declare function generateDbTs(inputSchema: ZiteSchema): string;
 export type EndpointFileInfo = {
     fileName: string;
     content?: string;

package/dist/cjs/sync/lib.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPascalCase = toPascalCase;
-exports.toCamelCase = toCamelCase;
-exports.toSdkName = toSdkName;
+exports.toSdkName = exports.toCamelCase = exports.toPascalCase = void 0;
 exports.generateSchema = generateSchema;
 exports.generateDbTs = generateDbTs;
 exports.generateApiTs = generateApiTs;
@@ -10,6 +8,7 @@ exports.generateAirtableTs = generateAirtableTs;
 exports.generateBackendWrapperTs = generateBackendWrapperTs;
 exports.generateEmailSdk = generateEmailSdk;
 const parser_1 = require("@babel/parser");
+const sdkNames_js_1 = require("./sdkNames.js");
 const AUTH_USERS_TABLE_ID = "zite_user";
 /**
  * What a field's value looks like when a record is READ back.
@@ -181,47 +180,12 @@ const withDateFormatExample = (format) => {
         ? `"${format}" format (e.g. ${example})`
         : `"${format}" format`;
 };
-function toPascalCase(name) {
-    const pascal = name
-        .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
-        .replace(/^(.)/, (_, c) => c.toUpperCase())
-        // Drop leftover non-alphanumerics (e.g. a trailing ">" from "</p>") so the
-        // sdkName is always a valid identifier in .zite/db.ts.
-        .replace(/[^a-zA-Z0-9]+/g, "");
-    if (!pascal)
-        return "_";
-    return /^[0-9]/.test(pascal) ? `_${pascal}` : pascal; // can't start with a digit
-}
-function toCamelCase(name) {
-    const pascal = toPascalCase(name);
-    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-/**
- * camelCase for a FRESH sdkName, reading acronym runs as words: "VIP" ->
- * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey").
- *
- * Deliberately not folded into toCamelCase: that also derives endpoint
- * identifiers from existing filenames on every generate, where normalizing
- * would rename a working app's `api.sendSMS`. This is only for names being
- * chosen for the first time — generateSchema preserves existing sdkNames.
- */
-function toSdkName(name) {
-    const deAcronymed = name
-        .replace(/([A-Z]+)([A-Z][a-z])/g, (_, run, next) => run.charAt(0) + run.slice(1).toLowerCase() + next)
-        .replace(/([A-Z])([A-Z]+)/g, (_, first, rest) => first + rest.toLowerCase());
-    return toCamelCase(deAcronymed);
-}
-/**
- * Existing sdkNames are preserved across syncs so user code keeps compiling,
- * but schemas written before the sanitizer stripped trailing symbols can carry
- * invalid identifiers (e.g. "timeSeconds)"). Keep an existing name only when
- * it's a valid identifier; otherwise fall through to recomputing it.
- */
-function keepValidSdkName(sdkName) {
-    if (!sdkName)
-        return undefined;
-    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(sdkName) ? sdkName : undefined;
-}
+// Owned by ./sdkNames.ts (which must not import back into this module);
+// re-exported so the published surface is unchanged.
+var sdkNames_js_2 = require("./sdkNames.js");
+Object.defineProperty(exports, "toPascalCase", { enumerable: true, get: function () { return sdkNames_js_2.toPascalCase; } });
+Object.defineProperty(exports, "toCamelCase", { enumerable: true, get: function () { return sdkNames_js_2.toCamelCase; } });
+Object.defineProperty(exports, "toSdkName", { enumerable: true, get: function () { return sdkNames_js_2.toSdkName; } });
 /**
  * `null` is how you CLEAR a cell — every scalar write schema in
  * `flexible-inputs.ts` ends in `.nullable()` and update runs with
@@ -364,7 +328,7 @@ function generateSchema(database, existingSchema) {
     for (const t of existingSchema?.tables ?? []) {
         existingTableById.set(t.id, t);
     }
-    const tables = [];
+    const drafts = [];
     for (const table of database.tables) {
         if (table.id === AUTH_USERS_TABLE_ID)
             continue;
@@ -373,23 +337,44 @@ function generateSchema(database, existingSchema) {
         for (const f of existingTable?.fields ?? []) {
             existingFieldById.set(f.id, f);
         }
-        const fields = [];
-        for (const field of table.fields) {
-            const existing = existingFieldById.get(field.id);
+        // `sdkName` is filled in by `allocateSchemaNames` below; the draft carries
+        // what each name would like to be and whether user code already depends on
+        // it. A name from the existing schema is locked — it is what the app is
+        // compiling against — and only moves if it is reserved or collides.
+        const fields = table.fields.map((field) => {
+            const existing = (0, sdkNames_js_1.keepValidSdkName)(existingFieldById.get(field.id)?.sdkName);
             const { id: _id, order: _order, ...definition } = field;
-            fields.push({
-                id: field.id,
-                sdkName: keepValidSdkName(existing?.sdkName) ?? toSdkName(field.name),
-                definition,
-            });
-        }
-        tables.push({
-            id: table.id,
-            sdkName: keepValidSdkName(existingTable?.sdkName) ?? toSdkName(table.name),
-            primaryFieldId: table.primaryFieldId,
+            return {
+                field: { id: field.id, sdkName: "", definition },
+                draft: {
+                    preferred: existing ?? (0, sdkNames_js_1.toSdkName)(field.name),
+                    locked: existing !== undefined,
+                },
+            };
+        });
+        const existingName = (0, sdkNames_js_1.keepValidSdkName)(existingTable?.sdkName);
+        drafts.push({
+            table: {
+                id: table.id,
+                sdkName: "",
+                primaryFieldId: table.primaryFieldId,
+                fields: [],
+            },
+            draft: {
+                preferred: existingName ?? (0, sdkNames_js_1.toSdkName)(table.name),
+                locked: existingName !== undefined,
+            },
             fields,
         });
     }
+    const { tables, renames } = (0, sdkNames_js_1.allocateSchemaNames)(drafts);
+    if (renames.length > 0) {
+        // Never silent: a rename means the accessor a developer would reach for is
+        // not the one that got emitted.
+        for (const line of (0, sdkNames_js_1.describeRenames)(renames)) {
+            console.warn(`[zitejs] SDK name collision resolved: ${line}`);
+        }
+    }
     return { tables };
 }
 function generateSentinelSdkTypes() {
@@ -445,8 +430,8 @@ function buildLinkTableComments(schema) {
             const target = tablesById.get(targetId);
             if (!target)
                 continue;
-            const sourceSdk = toPascalCase(table.sdkName);
-            const targetSdk = toPascalCase(target.sdkName);
+            const sourceSdk = (0, sdkNames_js_1.toPascalCase)(table.sdkName);
+            const targetSdk = (0, sdkNames_js_1.toPascalCase)(target.sdkName);
             const [first, second] = [sourceSdk, targetSdk].sort();
             const linkName = `${first}${second}`;
             if (seen.has(linkName))
@@ -477,8 +462,20 @@ function buildLinkTableComments(schema) {
  * Generate .zite/db.ts purely from ZiteSchema.
  * Pure function — no external data needed beyond what's in the schema file.
  */
-function generateDbTs(schema) {
+function generateDbTs(inputSchema) {
     const lines = [];
+    // Defensive, and idempotent: a schema whose names are already unique and
+    // unreserved normalizes to itself. It matters for a `zite.schema.json`
+    // committed before allocation existed — the sandbox's boot-time
+    // `zitejs generate` reads that file directly, with no `generateSchema` pass
+    // in front of it, and would otherwise emit an object literal with a
+    // duplicate key (TS1117) that no build can recover from.
+    const { schema, renames } = (0, sdkNames_js_1.normalizeSchemaNames)(inputSchema);
+    if (renames.length > 0) {
+        for (const line of (0, sdkNames_js_1.describeRenames)(renames)) {
+            console.warn(`[zitejs] Repaired SDK name in zite.schema.json: ${line}`);
+        }
+    }
     const tables = schema.tables.filter((table) => table.id !== AUTH_USERS_TABLE_ID);
     lines.push("// Auto-generated by zitejs generate. Do not edit manually.");
     lines.push("//");
@@ -542,7 +539,7 @@ function generateDbTs(schema) {
     lines.push("");
     lines.push(...ATTACHMENT_TYPES);
     for (const table of tables) {
-        const className = toPascalCase(table.sdkName);
+        const className = (0, sdkNames_js_1.toPascalCase)(table.sdkName);
         const recordType = `${className}RecordType`;
         lines.push(`/** A ${table.sdkName} record as it is read back. */`);
         lines.push(`export type ${recordType} = {`);
@@ -579,7 +576,7 @@ function generateDbTs(schema) {
     lines.push(...generateSentinelSdkTypes());
     lines.push("export const zite = {");
     for (const table of tables) {
-        const className = toPascalCase(table.sdkName);
+        const className = (0, sdkNames_js_1.toPascalCase)(table.sdkName);
         lines.push(`  ${table.sdkName}: createTableClient<${className}RecordType, ${className}RecordInput>('${className}'),`);
     }
     lines.push(`  sql: createSqlClient(),`);
@@ -734,7 +731,7 @@ function generateApiTs(endpointFiles) {
             continue;
         }
         const baseName = fileName.replace(/\.(ts|js)$/, "");
-        const key = toCamelCase(baseName);
+        const key = (0, sdkNames_js_1.toCamelCase)(baseName);
         const ident = toSafeIdentifier(key);
         // Distinct files can collide on one identifier (`send-email.ts` and
         // `send_email.ts` both camelCase to `sendEmail`), which used to emit the
@@ -750,7 +747,7 @@ function generateApiTs(endpointFiles) {
             baseName,
             key,
             ident,
-            pascal: toPascalCase(key),
+            pascal: (0, sdkNames_js_1.toPascalCase)(key),
             stream: shape?.stream ?? false,
             // No content to inspect means a bare-filename caller, which historically
             // assumed a default export — keep that assumption.

package/dist/cjs/sync/sdkNames.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Allocation of the identifiers `generateDbTs` emits.
+ *
+ * Every accessor on the generated `zite` object, and every field key on a
+ * record type, has to be unique — and `generateSchema` used to choose them with
+ * `toSdkName` and no memory at all. Two consequences, both seen in the wild:
+ *
+ *   - A table named "Notifications" allocated `notifications`, which
+ *     `generateDbTs` also emits for the platform's notifications client. The
+ *     sentinel is written last, so it won: the table lost its client entirely
+ *     and typed as `{ create(params: NotificationsCreateParams) }`.
+ *   - Two fields whose display names normalize alike both claimed one accessor,
+ *     and the second silently overwrote the first in the emitted type. No
+ *     error, no diagnostic — just a column you could no longer read. Zite 1.0's
+ *     generator de-duplicated with numeric suffixes; 2.0 dropped that.
+ *
+ * `allocateSchemaNames` is idempotent: a schema whose names are already unique
+ * and unreserved allocates to itself. That is what lets `generateDbTs` run it
+ * defensively over its input — a schema file written before this existed
+ * repairs itself on the next generate instead of emitting TypeScript that
+ * cannot compile.
+ */
+import type { ZiteSchema, ZiteSchemaField, ZiteSchemaTable } from "./lib.js";
+export declare function toPascalCase(name: string): string;
+export declare function toCamelCase(name: string): string;
+/**
+ * camelCase for a FRESH sdkName, reading acronym runs as words: "VIP" ->
+ * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey").
+ *
+ * Deliberately not folded into toCamelCase: that also derives endpoint
+ * identifiers from existing filenames on every generate, where normalizing
+ * would rename a working app's `api.sendSMS`. This is only for names being
+ * chosen for the first time — generateSchema preserves existing sdkNames.
+ */
+export declare function toSdkName(name: string): string;
+/**
+ * Accessors `generateDbTs` puts on the `zite` object itself, after the tables.
+ * A table that allocates one of these produces a duplicate key.
+ */
+export declare const RESERVED_TABLE_ACCESSORS: readonly ["sql", "notifications", "auth"];
+/**
+ * Never safe as a generated key, in any namespace. Assigning `__proto__` in an
+ * object literal sets the prototype rather than defining a property, and
+ * `constructor` / `prototype` shadow members every object already carries.
+ */
+export declare const RESERVED_IDENTIFIERS: readonly ["__proto__", "constructor", "prototype"];
+/**
+ * `id` is emitted by hand on every record type and filtered out of every input
+ * type, so a field that allocated it vanished from both. Reserving it means a
+ * field genuinely named "ID" gets a usable accessor instead.
+ */
+export declare const RESERVED_FIELD_ACCESSORS: readonly ["id"];
+/** A name that could not be kept, reported so a rename is never silent. */
+export interface SdkNameRename {
+    kind: "table" | "field";
+    /** The table this happened in; the table itself for `kind: 'table'`. */
+    tableId: string;
+    fieldId?: string;
+    from: string;
+    to: string;
+}
+/**
+ * Existing sdkNames are preserved across syncs so user code keeps compiling,
+ * but a schema written before the sanitizer stripped trailing symbols can carry
+ * an invalid identifier (e.g. `timeSeconds)`). Keep one only when it is a valid
+ * identifier; otherwise the caller recomputes it from the display name.
+ */
+export declare function keepValidSdkName(sdkName: string | undefined): string | undefined;
+/** What a table/field would like to be called, and how hard it is holding on. */
+interface NameDraft {
+    preferred: string;
+    /**
+     * True when the name is already baked into a committed schema and user code
+     * is compiling against it. Locked names are claimed first, so a fresh name
+     * can never displace one; a locked name still moves when it is reserved or
+     * when two locked names collide, because the alternative is a file that does
+     * not compile.
+     */
+    locked: boolean;
+}
+export interface SchemaNameDraft {
+    table: ZiteSchemaTable;
+    draft: NameDraft;
+    fields: Array<{
+        field: ZiteSchemaField;
+        draft: NameDraft;
+    }>;
+}
+/**
+ * Resolve every drafted name to a unique, unreserved one.
+ *
+ * Two passes per namespace: locked names claim first in declaration order, then
+ * fresh ones fill in around them. Without that ordering a new table could take
+ * an accessor an existing app already imports.
+ */
+export declare function allocateSchemaNames(drafts: SchemaNameDraft[]): {
+    tables: ZiteSchemaTable[];
+    renames: SdkNameRename[];
+};
+/**
+ * Repair a schema whose names may already be unique — the idempotent case — or
+ * may predate allocation entirely. Everything is treated as locked: these names
+ * are what user code compiles against, so only a genuine conflict moves one.
+ */
+export declare function normalizeSchemaNames(schema: ZiteSchema): {
+    schema: ZiteSchema;
+    renames: SdkNameRename[];
+};
+/** One line per rename, for a generator that has no logger of its own. */
+export declare function describeRenames(renames: SdkNameRename[]): string[];
+export {};