zitejs 0.9.111 → 0.9.112

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

@@ -9,6 +9,7 @@ export type ZiteSchemaField = {
 export type ZiteSchemaTable = {
     id: string;
     sdkName: string;
+    name?: string;
     primaryFieldId?: string;
     fields: ZiteSchemaField[];
 };
@@ -45,6 +46,7 @@ export type AirtableLockField = {
 export type AirtableLockTable = {
     id: string;
     sdkName: string;
+    name?: string;
     primaryFieldId: string;
     fields: AirtableLockField[];
 };

package/dist/cjs/sync/lib.js

@@ -268,9 +268,12 @@ function fieldJsdoc(schemaField, table, schema) {
         const tpl = def.template;
         if (tpl.tableId) {
             // The SDK name, not the raw `tbl...` id — the id appears nowhere the
-            // reader can act on, while the SDK name is the property on `zite`.
+            // reader can act on, while the SDK name is the property on `zite`. Its
+            // display name rides along, since after a rename the two differ.
             const linked = schema?.tables.find((t) => t.id === tpl.tableId);
-            parts.push(`Links to ${linked ? linked.sdkName : tpl.tableId}`);
+            parts.push(linked
+                ? `Links to ${linked.sdkName}${linked.name ? ` ("${linked.name}")` : ""}`
+                : `Links to ${tpl.tableId}`);
         }
         if (tpl.allowMultiple === false)
             parts.push("Single record only");
@@ -383,6 +386,10 @@ function generateSchema(database, existingSchema) {
             table: {
                 id: table.id,
                 sdkName: "",
+                // Always the live name — never `existingTable?.name`. Locking it the way
+                // `sdkName` is locked would freeze it at the first name the table ever
+                // had, which is the one thing this is here to avoid.
+                name: table.name,
                 primaryFieldId: table.primaryFieldId,
                 fields: [],
             },
@@ -441,6 +448,13 @@ function buildLinkTableComments(schema) {
     const tablesById = new Map();
     for (const t of schema.tables)
         tablesById.set(t.id, t);
+    // The link name itself is a literal SQL identifier ("use these exact names"),
+    // so it stays sdkName-derived; the display names ride alongside as a gloss.
+    const displayByPascal = new Map();
+    for (const t of schema.tables) {
+        if (t.name)
+            displayByPascal.set((0, sdkNames_js_1.toPascalCase)(t.sdkName), t.name);
+    }
     const seen = new Set();
     const entries = [];
     for (const table of schema.tables) {
@@ -470,7 +484,15 @@ function buildLinkTableComments(schema) {
             const col2 = isSelf
                 ? `target${second}Id`
                 : `${second.charAt(0).toLowerCase()}${second.slice(1)}Id`;
-            entries.push({ name: linkName, cols: [col1, col2] });
+            const firstName = displayByPascal.get(first);
+            const secondName = displayByPascal.get(second);
+            entries.push({
+                name: linkName,
+                cols: [col1, col2],
+                gloss: firstName && secondName
+                    ? `joins "${firstName}" and "${secondName}"`
+                    : undefined,
+            });
         }
     }
     if (entries.length === 0)
@@ -480,7 +502,8 @@ function buildLinkTableComments(schema) {
         "// Link tables for zite.sql() JOINs (use these exact names):",
     ];
     for (const e of entries) {
-        lines.push(`//   "${commentSafe(e.name)}" — columns: "${commentSafe(e.cols[0])}", "${commentSafe(e.cols[1])}"`);
+        lines.push(`//   "${commentSafe(e.name)}" — columns: "${commentSafe(e.cols[0])}", "${commentSafe(e.cols[1])}"` +
+            (e.gloss ? ` (${commentSafe(e.gloss)})` : ""));
     }
     return lines;
 }
@@ -567,7 +590,12 @@ function generateDbTs(inputSchema) {
     for (const table of tables) {
         const className = (0, sdkNames_js_1.toPascalCase)(table.sdkName);
         const recordType = `${className}RecordType`;
-        lines.push(`/** A ${table.sdkName} record as it is read back. */`);
+        // A schema written before `name` existed keeps the old wording exactly —
+        // sandbox boot regenerates unconditionally, so any drift here would show up
+        // as an unexplained diff in every project's next commit.
+        lines.push(table.name
+            ? `/** A record in the "${commentSafe(table.name)}" table, as it is read back. */`
+            : `/** A ${table.sdkName} record as it is read back. */`);
         lines.push(`export type ${recordType} = {`);
         lines.push("  id: string;");
         for (const field of table.fields) {
@@ -591,7 +619,9 @@ function generateDbTs(inputSchema) {
         // input than they store (an attachments field takes a URL string; a linked
         // record takes one id or many).
         const writableFields = table.fields.filter((f) => f.sdkName !== "id" && !READ_ONLY_FIELD_TYPES.has(f.definition.type));
-        lines.push(`/** What you may write when creating or updating a ${table.sdkName}. */`);
+        lines.push(table.name
+            ? `/** What you may write when creating or updating a record in the "${commentSafe(table.name)}" table. */`
+            : `/** What you may write when creating or updating a ${table.sdkName}. */`);
         lines.push(`export type ${className}RecordInput = {`);
         for (const field of writableFields) {
             lines.push(`  ${field.sdkName}: ${tsTypeForSchemaField(field.definition, "write")};`);
@@ -603,7 +633,8 @@ function generateDbTs(inputSchema) {
     lines.push("export const zite = {");
     for (const table of tables) {
         const className = (0, sdkNames_js_1.toPascalCase)(table.sdkName);
-        lines.push(`  ${table.sdkName}: createTableClient<${className}RecordType, ${className}RecordInput>('${className}'),`);
+        lines.push(`  ${table.sdkName}: createTableClient<${className}RecordType, ${className}RecordInput>('${className}'),` +
+            (table.name ? ` // "${commentSafe(table.name)}"` : ""));
     }
     lines.push(`  sql: createSqlClient(),`);
     // No `notifications` here: it is a platform primitive, not something backed
@@ -1002,7 +1033,9 @@ function airtableFieldJsdoc(field, table, lock) {
         const linkedTableId = field.config?.linkedTableId;
         if (linkedTableId) {
             const linked = lock?.tables.find((t) => t.id === linkedTableId);
-            parts.push(`Links to ${linked ? linked.sdkName : linkedTableId}`);
+            parts.push(linked
+                ? `Links to ${linked.sdkName}${linked.name ? ` ("${linked.name}")` : ""}`
+                : `Links to ${linkedTableId}`);
         }
         if (field.config?.prefersSingleRecordLink)
             parts.push("Single record only");
@@ -1160,7 +1193,9 @@ function generateAirtableTs(inputLock) {
     lines.push(...AIRTABLE_ATTACHMENT_TYPE);
     for (const table of lock.tables) {
         const recordType = `${table.sdkName}RecordType`;
-        lines.push(`/** A ${commentSafe(table.sdkName)} record as it is read back. */`);
+        lines.push(table.name
+            ? `/** A record in the "${commentSafe(table.name)}" table, as it is read back. */`
+            : `/** A ${commentSafe(table.sdkName)} record as it is read back. */`);
         lines.push(`export type ${recordType} = {`);
         lines.push("  id: string;");
         for (const field of table.fields) {
@@ -1182,7 +1217,9 @@ function generateAirtableTs(inputLock) {
         // Read-only fields are omitted rather than typed: Airtable rejects a write
         // to a formula, rollup, lookup or autonumber with a 422.
         const writableFields = table.fields.filter((f) => f.sdkName !== "id" && !READ_ONLY_AIRTABLE_FIELDS.has(f.type));
-        lines.push(`/** What you may write when creating or updating a ${commentSafe(table.sdkName)}. */`);
+        lines.push(table.name
+            ? `/** What you may write when creating or updating a record in the "${commentSafe(table.name)}" table. */`
+            : `/** What you may write when creating or updating a ${commentSafe(table.sdkName)}. */`);
         lines.push(`export type ${table.sdkName}RecordInput = {`);
         for (const field of writableFields) {
             lines.push(`  ${field.sdkName}: ${airtableTsType(field, lock, 0, "write")};`);
@@ -1192,7 +1229,8 @@ function generateAirtableTs(inputLock) {
         lines.push(`export const ${table.sdkName} = createAirtableClient<${recordType}, ${table.sdkName}RecordInput>(`);
         lines.push(`  '${lock.integrationId}',`);
         lines.push(`  '${table.sdkName}',`);
-        lines.push(`  { tableId: '${table.id}' },`);
+        lines.push(`  { tableId: '${table.id}' },` +
+            (table.name ? ` // "${commentSafe(table.name)}"` : ""));
         lines.push(`);`);
         lines.push("");
     }

package/dist/cjs/sync/lib.test.js

@@ -282,6 +282,56 @@ const duplicateIdentifierErrorsIn = (source) => {
         (0, vitest_1.expect)(syntaxErrorsIn((0, lib_js_1.generateDbTs)(schemaWithFieldNamed(name)))).toEqual([]);
     });
 });
+(0, vitest_1.describe)('generateDbTs table names in comments', () => {
+    const schemaWithTableNamed = (name) => ({
+        tables: [
+            {
+                id: 'tbl1',
+                sdkName: 'table1',
+                ...(name === undefined ? {} : { name }),
+                primaryFieldId: 'fld1',
+                fields: [
+                    {
+                        id: 'fld1',
+                        sdkName: 'slot',
+                        definition: {
+                            type: 'single_line_text',
+                            name: 'Slot',
+                            template: {},
+                        },
+                    },
+                ],
+            },
+        ],
+    });
+    // The whole point: `sdkName` is locked to the table's id, so after a rename
+    // `table1` is the only thing a reader sees. The display name is what says
+    // which table that is.
+    (0, vitest_1.it)('names the table beside its locked sdkName', () => {
+        const out = (0, lib_js_1.generateDbTs)(schemaWithTableNamed('Time Slots'));
+        (0, vitest_1.expect)(out).toContain('/** A record in the "Time Slots" table, as it is read back. */');
+        (0, vitest_1.expect)(out).toContain('/** What you may write when creating or updating a record in the "Time Slots" table. */');
+        (0, vitest_1.expect)(out).toContain(`table1: createTableClient<Table1RecordType, Table1RecordInput>('Table1'), // "Time Slots"`);
+    });
+    // Sandbox boot regenerates unconditionally against the committed schema, so a
+    // schema written before `name` existed has to keep producing what it did
+    // before — otherwise every project's next commit carries an unexplained diff.
+    (0, vitest_1.it)('emits the pre-name wording when the schema carries no name', () => {
+        const out = (0, lib_js_1.generateDbTs)(schemaWithTableNamed(undefined));
+        (0, vitest_1.expect)(out).toContain('/** A table1 record as it is read back. */');
+        (0, vitest_1.expect)(out).toContain('/** What you may write when creating or updating a table1. */');
+        (0, vitest_1.expect)(out).toContain(`('Table1'),\n`);
+        (0, vitest_1.expect)(out).not.toContain('" table, as it is read back');
+    });
+    // Same hazard as a field name, one level up: a table's display name is user
+    // text and now reaches a JSDoc.
+    vitest_1.it.each([
+        ['a comment-close sequence', 'Slots */ console.log(1); /*'],
+        ['a newline', 'Time\nSlots'],
+    ])('emits parseable TypeScript for a table named with %s', (_what, name) => {
+        (0, vitest_1.expect)(syntaxErrorsIn((0, lib_js_1.generateDbTs)(schemaWithTableNamed(name)))).toEqual([]);
+    });
+});
 (0, vitest_1.describe)('generateApiTs endpoint file names', () => {
     // An endpoint filename is the LLM's raw `writeFile` path argument — nothing
     // validates its characters — and it lands in an import specifier, a comment

package/dist/cjs/sync/sdkNames.test.js

@@ -207,3 +207,31 @@ const recordTypeKeys = (source, typeName) => {
         (0, vitest_1.expect)(keys).toContain("sql2");
     });
 });
+(0, vitest_1.describe)("table display names", () => {
+    // `sdkName` is locked to the id so user code keeps compiling; `name` is the
+    // opposite and must always take the live value. Locking it too — the easy
+    // mistake, since the line above it does exactly that — freezes it at the
+    // table's first name and defeats the point.
+    (0, vitest_1.it)("follows a rename while the sdkName stays locked", () => {
+        const first = (0, lib_js_1.generateSchema)(database([{ id: "tbl_1", name: "Slots", fields: [field("fld_1", "At")] }]));
+        (0, vitest_1.expect)(first.tables[0].sdkName).toBe("slots");
+        (0, vitest_1.expect)(first.tables[0].name).toBe("Slots");
+        const renamed = (0, lib_js_1.generateSchema)(database([
+            { id: "tbl_1", name: "Time Slots", fields: [field("fld_1", "At")] },
+        ]), first);
+        (0, vitest_1.expect)(renamed.tables[0].sdkName).toBe("slots");
+        (0, vitest_1.expect)(renamed.tables[0].name).toBe("Time Slots");
+        (0, vitest_1.expect)((0, lib_js_1.generateDbTs)(renamed)).toContain('/** A record in the "Time Slots" table, as it is read back. */');
+    });
+    // `buildLegacySchemaSeed` (restly, migration) builds a seed carrying only
+    // `sdkName`. Reading `name` off the seed would emit `undefined` for every
+    // table on every newly migrated project.
+    (0, vitest_1.it)("takes the live name even when the seed has none", () => {
+        const seed = {
+            tables: [{ id: "tbl_1", sdkName: "salesDeals", fields: [] }],
+        };
+        const schema = (0, lib_js_1.generateSchema)(database([{ id: "tbl_1", name: "Deals", fields: [] }]), seed);
+        (0, vitest_1.expect)(schema.tables[0].sdkName).toBe("salesDeals");
+        (0, vitest_1.expect)(schema.tables[0].name).toBe("Deals");
+    });
+});

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

@@ -9,6 +9,7 @@ export type ZiteSchemaField = {
 export type ZiteSchemaTable = {
     id: string;
     sdkName: string;
+    name?: string;
     primaryFieldId?: string;
     fields: ZiteSchemaField[];
 };
@@ -45,6 +46,7 @@ export type AirtableLockField = {
 export type AirtableLockTable = {
     id: string;
     sdkName: string;
+    name?: string;
     primaryFieldId: string;
     fields: AirtableLockField[];
 };

package/dist/esm/sync/lib.js

@@ -255,9 +255,12 @@ function fieldJsdoc(schemaField, table, schema) {
         const tpl = def.template;
         if (tpl.tableId) {
             // The SDK name, not the raw `tbl...` id — the id appears nowhere the
-            // reader can act on, while the SDK name is the property on `zite`.
+            // reader can act on, while the SDK name is the property on `zite`. Its
+            // display name rides along, since after a rename the two differ.
             const linked = schema?.tables.find((t) => t.id === tpl.tableId);
-            parts.push(`Links to ${linked ? linked.sdkName : tpl.tableId}`);
+            parts.push(linked
+                ? `Links to ${linked.sdkName}${linked.name ? ` ("${linked.name}")` : ""}`
+                : `Links to ${tpl.tableId}`);
         }
         if (tpl.allowMultiple === false)
             parts.push("Single record only");
@@ -370,6 +373,10 @@ export function generateSchema(database, existingSchema) {
             table: {
                 id: table.id,
                 sdkName: "",
+                // Always the live name — never `existingTable?.name`. Locking it the way
+                // `sdkName` is locked would freeze it at the first name the table ever
+                // had, which is the one thing this is here to avoid.
+                name: table.name,
                 primaryFieldId: table.primaryFieldId,
                 fields: [],
             },
@@ -428,6 +435,13 @@ function buildLinkTableComments(schema) {
     const tablesById = new Map();
     for (const t of schema.tables)
         tablesById.set(t.id, t);
+    // The link name itself is a literal SQL identifier ("use these exact names"),
+    // so it stays sdkName-derived; the display names ride alongside as a gloss.
+    const displayByPascal = new Map();
+    for (const t of schema.tables) {
+        if (t.name)
+            displayByPascal.set(toPascalCase(t.sdkName), t.name);
+    }
     const seen = new Set();
     const entries = [];
     for (const table of schema.tables) {
@@ -457,7 +471,15 @@ function buildLinkTableComments(schema) {
             const col2 = isSelf
                 ? `target${second}Id`
                 : `${second.charAt(0).toLowerCase()}${second.slice(1)}Id`;
-            entries.push({ name: linkName, cols: [col1, col2] });
+            const firstName = displayByPascal.get(first);
+            const secondName = displayByPascal.get(second);
+            entries.push({
+                name: linkName,
+                cols: [col1, col2],
+                gloss: firstName && secondName
+                    ? `joins "${firstName}" and "${secondName}"`
+                    : undefined,
+            });
         }
     }
     if (entries.length === 0)
@@ -467,7 +489,8 @@ function buildLinkTableComments(schema) {
         "// Link tables for zite.sql() JOINs (use these exact names):",
     ];
     for (const e of entries) {
-        lines.push(`//   "${commentSafe(e.name)}" — columns: "${commentSafe(e.cols[0])}", "${commentSafe(e.cols[1])}"`);
+        lines.push(`//   "${commentSafe(e.name)}" — columns: "${commentSafe(e.cols[0])}", "${commentSafe(e.cols[1])}"` +
+            (e.gloss ? ` (${commentSafe(e.gloss)})` : ""));
     }
     return lines;
 }
@@ -554,7 +577,12 @@ export function generateDbTs(inputSchema) {
     for (const table of tables) {
         const className = toPascalCase(table.sdkName);
         const recordType = `${className}RecordType`;
-        lines.push(`/** A ${table.sdkName} record as it is read back. */`);
+        // A schema written before `name` existed keeps the old wording exactly —
+        // sandbox boot regenerates unconditionally, so any drift here would show up
+        // as an unexplained diff in every project's next commit.
+        lines.push(table.name
+            ? `/** A record in the "${commentSafe(table.name)}" table, as it is read back. */`
+            : `/** A ${table.sdkName} record as it is read back. */`);
         lines.push(`export type ${recordType} = {`);
         lines.push("  id: string;");
         for (const field of table.fields) {
@@ -578,7 +606,9 @@ export function generateDbTs(inputSchema) {
         // input than they store (an attachments field takes a URL string; a linked
         // record takes one id or many).
         const writableFields = table.fields.filter((f) => f.sdkName !== "id" && !READ_ONLY_FIELD_TYPES.has(f.definition.type));
-        lines.push(`/** What you may write when creating or updating a ${table.sdkName}. */`);
+        lines.push(table.name
+            ? `/** What you may write when creating or updating a record in the "${commentSafe(table.name)}" table. */`
+            : `/** What you may write when creating or updating a ${table.sdkName}. */`);
         lines.push(`export type ${className}RecordInput = {`);
         for (const field of writableFields) {
             lines.push(`  ${field.sdkName}: ${tsTypeForSchemaField(field.definition, "write")};`);
@@ -590,7 +620,8 @@ export function generateDbTs(inputSchema) {
     lines.push("export const zite = {");
     for (const table of tables) {
         const className = toPascalCase(table.sdkName);
-        lines.push(`  ${table.sdkName}: createTableClient<${className}RecordType, ${className}RecordInput>('${className}'),`);
+        lines.push(`  ${table.sdkName}: createTableClient<${className}RecordType, ${className}RecordInput>('${className}'),` +
+            (table.name ? ` // "${commentSafe(table.name)}"` : ""));
     }
     lines.push(`  sql: createSqlClient(),`);
     // No `notifications` here: it is a platform primitive, not something backed
@@ -989,7 +1020,9 @@ function airtableFieldJsdoc(field, table, lock) {
         const linkedTableId = field.config?.linkedTableId;
         if (linkedTableId) {
             const linked = lock?.tables.find((t) => t.id === linkedTableId);
-            parts.push(`Links to ${linked ? linked.sdkName : linkedTableId}`);
+            parts.push(linked
+                ? `Links to ${linked.sdkName}${linked.name ? ` ("${linked.name}")` : ""}`
+                : `Links to ${linkedTableId}`);
         }
         if (field.config?.prefersSingleRecordLink)
             parts.push("Single record only");
@@ -1147,7 +1180,9 @@ export function generateAirtableTs(inputLock) {
     lines.push(...AIRTABLE_ATTACHMENT_TYPE);
     for (const table of lock.tables) {
         const recordType = `${table.sdkName}RecordType`;
-        lines.push(`/** A ${commentSafe(table.sdkName)} record as it is read back. */`);
+        lines.push(table.name
+            ? `/** A record in the "${commentSafe(table.name)}" table, as it is read back. */`
+            : `/** A ${commentSafe(table.sdkName)} record as it is read back. */`);
         lines.push(`export type ${recordType} = {`);
         lines.push("  id: string;");
         for (const field of table.fields) {
@@ -1169,7 +1204,9 @@ export function generateAirtableTs(inputLock) {
         // Read-only fields are omitted rather than typed: Airtable rejects a write
         // to a formula, rollup, lookup or autonumber with a 422.
         const writableFields = table.fields.filter((f) => f.sdkName !== "id" && !READ_ONLY_AIRTABLE_FIELDS.has(f.type));
-        lines.push(`/** What you may write when creating or updating a ${commentSafe(table.sdkName)}. */`);
+        lines.push(table.name
+            ? `/** What you may write when creating or updating a record in the "${commentSafe(table.name)}" table. */`
+            : `/** What you may write when creating or updating a ${commentSafe(table.sdkName)}. */`);
         lines.push(`export type ${table.sdkName}RecordInput = {`);
         for (const field of writableFields) {
             lines.push(`  ${field.sdkName}: ${airtableTsType(field, lock, 0, "write")};`);
@@ -1179,7 +1216,8 @@ export function generateAirtableTs(inputLock) {
         lines.push(`export const ${table.sdkName} = createAirtableClient<${recordType}, ${table.sdkName}RecordInput>(`);
         lines.push(`  '${lock.integrationId}',`);
         lines.push(`  '${table.sdkName}',`);
-        lines.push(`  { tableId: '${table.id}' },`);
+        lines.push(`  { tableId: '${table.id}' },` +
+            (table.name ? ` // "${commentSafe(table.name)}"` : ""));
         lines.push(`);`);
         lines.push("");
     }

package/dist/esm/sync/lib.test.js

@@ -277,6 +277,56 @@ describe('generateDbTs field names in comments', () => {
         expect(syntaxErrorsIn(generateDbTs(schemaWithFieldNamed(name)))).toEqual([]);
     });
 });
+describe('generateDbTs table names in comments', () => {
+    const schemaWithTableNamed = (name) => ({
+        tables: [
+            {
+                id: 'tbl1',
+                sdkName: 'table1',
+                ...(name === undefined ? {} : { name }),
+                primaryFieldId: 'fld1',
+                fields: [
+                    {
+                        id: 'fld1',
+                        sdkName: 'slot',
+                        definition: {
+                            type: 'single_line_text',
+                            name: 'Slot',
+                            template: {},
+                        },
+                    },
+                ],
+            },
+        ],
+    });
+    // The whole point: `sdkName` is locked to the table's id, so after a rename
+    // `table1` is the only thing a reader sees. The display name is what says
+    // which table that is.
+    it('names the table beside its locked sdkName', () => {
+        const out = generateDbTs(schemaWithTableNamed('Time Slots'));
+        expect(out).toContain('/** A record in the "Time Slots" table, as it is read back. */');
+        expect(out).toContain('/** What you may write when creating or updating a record in the "Time Slots" table. */');
+        expect(out).toContain(`table1: createTableClient<Table1RecordType, Table1RecordInput>('Table1'), // "Time Slots"`);
+    });
+    // Sandbox boot regenerates unconditionally against the committed schema, so a
+    // schema written before `name` existed has to keep producing what it did
+    // before — otherwise every project's next commit carries an unexplained diff.
+    it('emits the pre-name wording when the schema carries no name', () => {
+        const out = generateDbTs(schemaWithTableNamed(undefined));
+        expect(out).toContain('/** A table1 record as it is read back. */');
+        expect(out).toContain('/** What you may write when creating or updating a table1. */');
+        expect(out).toContain(`('Table1'),\n`);
+        expect(out).not.toContain('" table, as it is read back');
+    });
+    // Same hazard as a field name, one level up: a table's display name is user
+    // text and now reaches a JSDoc.
+    it.each([
+        ['a comment-close sequence', 'Slots */ console.log(1); /*'],
+        ['a newline', 'Time\nSlots'],
+    ])('emits parseable TypeScript for a table named with %s', (_what, name) => {
+        expect(syntaxErrorsIn(generateDbTs(schemaWithTableNamed(name)))).toEqual([]);
+    });
+});
 describe('generateApiTs endpoint file names', () => {
     // An endpoint filename is the LLM's raw `writeFile` path argument — nothing
     // validates its characters — and it lands in an import specifier, a comment

package/dist/esm/sync/sdkNames.test.js

@@ -205,3 +205,31 @@ describe("normalizeSchemaNames", () => {
         expect(keys).toContain("sql2");
     });
 });
+describe("table display names", () => {
+    // `sdkName` is locked to the id so user code keeps compiling; `name` is the
+    // opposite and must always take the live value. Locking it too — the easy
+    // mistake, since the line above it does exactly that — freezes it at the
+    // table's first name and defeats the point.
+    it("follows a rename while the sdkName stays locked", () => {
+        const first = generateSchema(database([{ id: "tbl_1", name: "Slots", fields: [field("fld_1", "At")] }]));
+        expect(first.tables[0].sdkName).toBe("slots");
+        expect(first.tables[0].name).toBe("Slots");
+        const renamed = generateSchema(database([
+            { id: "tbl_1", name: "Time Slots", fields: [field("fld_1", "At")] },
+        ]), first);
+        expect(renamed.tables[0].sdkName).toBe("slots");
+        expect(renamed.tables[0].name).toBe("Time Slots");
+        expect(generateDbTs(renamed)).toContain('/** A record in the "Time Slots" table, as it is read back. */');
+    });
+    // `buildLegacySchemaSeed` (restly, migration) builds a seed carrying only
+    // `sdkName`. Reading `name` off the seed would emit `undefined` for every
+    // table on every newly migrated project.
+    it("takes the live name even when the seed has none", () => {
+        const seed = {
+            tables: [{ id: "tbl_1", sdkName: "salesDeals", fields: [] }],
+        };
+        const schema = generateSchema(database([{ id: "tbl_1", name: "Deals", fields: [] }]), seed);
+        expect(schema.tables[0].sdkName).toBe("salesDeals");
+        expect(schema.tables[0].name).toBe("Deals");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.111",
+  "version": "0.9.112",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",