zitejs 0.9.104 → 0.9.106

package/dist/cjs/auth/index.js

@@ -7,6 +7,7 @@ exports.logout = logout;
 exports.updateProfile = updateProfile;
 const react_1 = require("better-auth/react");
 const plugins_1 = require("better-auth/client/plugins");
+const constants_js_1 = require("./constants.js");
 const authClient = (0, react_1.createAuthClient)({
     baseURL: '',
     plugins: [
@@ -57,10 +58,21 @@ function loginWithRedirect(opts) {
     // the address bar of every logged-out visitor to the front page, which is the
     // common case. Only pass a destination when it IS one.
     const isRoot = target.pathname === '/' && target.search === '' && target.hash === '';
-    window.location.href = isRoot
-        ? '/auth/login'
-        : '/auth/login?' +
-            new URLSearchParams({ redirectUrl: target.toString() }).toString();
+    const params = new URLSearchParams();
+    if (!isRoot)
+        params.set('redirectUrl', target.toString());
+    // The editor preview rides its usageToken on the app URL; the sign-in page
+    // only shows its editor surface ("Preview as" picker) when that token reaches
+    // it. Capturing the current URL carries it implicitly — but an explicit
+    // `redirectUrl` names a bare path, and would silently drop it. Forward it
+    // top-level either way, so how the app phrases its redirect can't decide
+    // whether the editor gets a preview. Published visitors never have one.
+    const usageToken = new URL(window.location.href).searchParams.get(constants_js_1.USAGE_TOKEN_QUERY_PARAM) ??
+        window._ziteUsageToken;
+    if (usageToken)
+        params.set(constants_js_1.USAGE_TOKEN_QUERY_PARAM, usageToken);
+    const query = params.toString();
+    window.location.href = query ? `/auth/login?${query}` : '/auth/login';
 }
 function logout(opts) {
     (0, exports.signOut)().then(() => {

package/dist/cjs/auth/index.test.js

@@ -147,4 +147,43 @@ function redirectParamOf(href) {
         (0, vitest_1.expect)(params.get('view')).toBeNull();
         (0, vitest_1.expect)(params.get('redirectUrl')).toBe('https://app.zite.so/pricing');
     });
+    (0, vitest_1.it)('forwards the editor usageToken past an explicit redirectUrl', () => {
+        // The editor preview rides its token on the app URL. An explicit
+        // redirectUrl names a bare path, which used to silently drop it — and with
+        // it the sign-in page's whole editor surface ("Preview as" picker).
+        const location = stubLocation('https://app.zite.so/?usageToken=tok-123');
+        authExports.loginWithRedirect({ redirectUrl: '/dashboard' });
+        const params = new URLSearchParams(location.href.split('?')[1] ?? '');
+        (0, vitest_1.expect)(params.get('usageToken')).toBe('tok-123');
+        (0, vitest_1.expect)(params.get('redirectUrl')).toBe('https://app.zite.so/dashboard');
+    });
+    (0, vitest_1.it)('forwards the usageToken top-level on a bare call too', () => {
+        const location = stubLocation('https://app.zite.so/orders/123?usageToken=tok-123');
+        authExports.loginWithRedirect();
+        const params = new URLSearchParams(location.href.split('?')[1] ?? '');
+        (0, vitest_1.expect)(params.get('usageToken')).toBe('tok-123');
+    });
+    (0, vitest_1.it)('carries a token to a root destination that would otherwise say nothing', () => {
+        const location = stubLocation('https://app.zite.so/?usageToken=tok-123');
+        // The token is the whole search string here only if nothing else rides
+        // along — an explicit root override drops the query, exercising the
+        // token-only branch.
+        authExports.loginWithRedirect({ redirectUrl: '/' });
+        (0, vitest_1.expect)(location.href).toBe('/auth/login?usageToken=tok-123');
+    });
+    (0, vitest_1.it)('falls back to window._ziteUsageToken when the URL was scrubbed', () => {
+        // app-runner's injected boot script moves the token off the address bar
+        // into this global before the bundle runs.
+        const location = stubLocation('https://app.zite.so/pricing');
+        window._ziteUsageToken = 'tok-456';
+        authExports.loginWithRedirect({ redirectUrl: '/dashboard' });
+        const params = new URLSearchParams(location.href.split('?')[1] ?? '');
+        (0, vitest_1.expect)(params.get('usageToken')).toBe('tok-456');
+    });
+    (0, vitest_1.it)('adds no token param for ordinary visitors', () => {
+        const location = stubLocation('https://app.zite.so/pricing');
+        authExports.loginWithRedirect();
+        const params = new URLSearchParams(location.href.split('?')[1] ?? '');
+        (0, vitest_1.expect)(params.get('usageToken')).toBeNull();
+    });
 });

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 {};