zitejs 0.9.104 → 0.9.106

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

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { generateSchema, generateDbTs } from "./lib.js";
+import { normalizeSchemaNames } from "./sdkNames.js";
+// `generateSchema` warns on every rename; silence it so the suite stays
+// readable, and assert on the emitted names instead.
+beforeEach(() => {
+    vi.spyOn(console, "warn").mockImplementation(() => { });
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+const field = (id, name) => ({ id, name, type: "single_line_text", order: 0 });
+const database = (tables) => ({
+    id: "base_1",
+    name: "Base",
+    tables,
+    createdAt: "",
+    updatedAt: "",
+    url: "",
+});
+/** Every key in the emitted `export const zite = { … }` literal. */
+const ziteKeys = (source) => {
+    const body = source.slice(source.indexOf("export const zite = {"));
+    return [...body.matchAll(/^ {2}([A-Za-z_$][\w$]*):/gm)].map((m) => m[1]);
+};
+/** Every property key on one emitted record type. */
+const recordTypeKeys = (source, typeName) => {
+    const start = source.indexOf(`export type ${typeName} = {`);
+    const body = source.slice(start, source.indexOf("};", start));
+    return [...body.matchAll(/^ {2}([A-Za-z_$][\w$]*)\??:/gm)].map((m) => m[1]);
+};
+describe("reserved platform accessors", () => {
+    // Sudzy Dashboard: a table named "Notifications" emitted a second
+    // `notifications:` key, and the platform client — written last — won. The
+    // table lost findAll and typed as `{ create(NotificationsCreateParams) }`.
+    it("moves a table off the notifications accessor", () => {
+        const schema = generateSchema(database([{ id: "tbl_1", name: "Notifications", fields: [] }]));
+        expect(schema.tables[0].sdkName).toBe("notifications2");
+        const keys = ziteKeys(generateDbTs(schema));
+        expect(keys).toContain("notifications2");
+        expect(keys.filter((k) => k === "notifications")).toHaveLength(1);
+        expect(new Set(keys).size).toBe(keys.length);
+    });
+    it.each(["sql", "auth", "notifications"])("keeps the platform %s accessor for the platform", (reserved) => {
+        const schema = generateSchema(database([{ id: "tbl_1", name: reserved, fields: [] }]));
+        expect(schema.tables[0].sdkName).toBe(`${reserved}2`);
+        const keys = ziteKeys(generateDbTs(schema));
+        expect(new Set(keys).size).toBe(keys.length);
+    });
+    it.each(["__proto__", "constructor", "prototype"])("refuses %s as a table accessor", (hazard) => {
+        const schema = generateSchema(database([{ id: "tbl_1", name: hazard, fields: [] }]));
+        expect(schema.tables[0].sdkName).not.toBe(hazard);
+    });
+});
+describe("collision de-duplication", () => {
+    // Nevada Car Coalition: 1.0's generator suffixed colliding names, so the app
+    // was written against `category1` / `sponsor1`. 2.0 had no accumulator at
+    // all, so the second field silently overwrote the first.
+    it("keeps both fields when two display names normalize alike", () => {
+        const schema = generateSchema(database([
+            {
+                id: "tbl_1",
+                name: "K9 Winners",
+                fields: [field("fld_1", "Category"), field("fld_2", "category")],
+            },
+        ]));
+        const names = schema.tables[0].fields.map((f) => f.sdkName);
+        expect(names).toEqual(["category", "category2"]);
+        const keys = recordTypeKeys(generateDbTs(schema), "K9WinnersRecordType");
+        expect(keys).toEqual(["id", "category", "category2"]);
+    });
+    it("de-duplicates two tables that normalize alike", () => {
+        const schema = generateSchema(database([
+            { id: "tbl_1", name: "Orders", fields: [] },
+            { id: "tbl_2", name: "orders", fields: [] },
+        ]));
+        expect(schema.tables.map((t) => t.sdkName)).toEqual(["orders", "orders2"]);
+    });
+    // Two sdkNames sharing a PascalCase form emit `FooRecordType` twice, which is
+    // a duplicate identifier even though the accessors differ.
+    it("separates tables whose class names would collide", () => {
+        const source = generateDbTs({
+            tables: [
+                { id: "tbl_1", sdkName: "orders", fields: [] },
+                { id: "tbl_2", sdkName: "Orders", fields: [] },
+            ],
+        });
+        const declared = [...source.matchAll(/export type (\w+RecordType)/g)].map((m) => m[1]);
+        expect(new Set(declared).size).toBe(declared.length);
+    });
+    it("reserves id so a field named ID stays readable", () => {
+        const schema = generateSchema(database([{ id: "tbl_1", name: "Rows", fields: [field("fld_1", "ID")] }]));
+        expect(schema.tables[0].fields[0].sdkName).toBe("id2");
+        expect(recordTypeKeys(generateDbTs(schema), "RowsRecordType")).toEqual([
+            "id",
+            "id2",
+        ]);
+    });
+});
+describe("name stability", () => {
+    const existing = {
+        tables: [
+            {
+                id: "tbl_1",
+                sdkName: "priceList",
+                fields: [
+                    { id: "fld_1", sdkName: "srp", definition: { type: "number" } },
+                ],
+            },
+        ],
+    };
+    // Kelly: the app was written against `srp`, and the field's display name has
+    // drifted since. A locked name is what the app compiles against.
+    it("preserves a locked name over the one the display name would produce", () => {
+        const schema = generateSchema(database([
+            {
+                id: "tbl_1",
+                name: "Price List",
+                fields: [field("fld_1", "SRP (Suggested Retail Price)")],
+            },
+        ]), existing);
+        expect(schema.tables[0].fields[0].sdkName).toBe("srp");
+    });
+    it("does not let a new field displace a locked one", () => {
+        const schema = generateSchema(database([
+            {
+                id: "tbl_1",
+                name: "Price List",
+                // The new field's fresh name is exactly what fld_1 holds.
+                fields: [field("fld_2", "SRP"), field("fld_1", "Anything")],
+            },
+        ]), existing);
+        const byId = Object.fromEntries(schema.tables[0].fields.map((f) => [f.id, f.sdkName]));
+        expect(byId.fld_1).toBe("srp");
+        expect(byId.fld_2).toBe("srp2");
+    });
+    it("is stable across repeated generation", () => {
+        const db = database([
+            {
+                id: "tbl_1",
+                name: "Notifications",
+                fields: [field("fld_1", "Category"), field("fld_2", "category")],
+            },
+        ]);
+        const first = generateSchema(db);
+        const second = generateSchema(db, first);
+        const third = generateSchema(db, second);
+        expect(second).toEqual(first);
+        expect(third).toEqual(first);
+    });
+    it("recomputes a name that is not a valid identifier", () => {
+        const schema = generateSchema(database([
+            { id: "tbl_1", name: "Rows", fields: [field("fld_1", "Time")] },
+        ]), {
+            tables: [
+                {
+                    id: "tbl_1",
+                    sdkName: "rows",
+                    fields: [
+                        {
+                            id: "fld_1",
+                            sdkName: "timeSeconds)",
+                            definition: { type: "number" },
+                        },
+                    ],
+                },
+            ],
+        });
+        expect(schema.tables[0].fields[0].sdkName).toBe("time");
+    });
+});
+describe("normalizeSchemaNames", () => {
+    it("is a no-op on a well-formed schema", () => {
+        const schema = {
+            tables: [
+                {
+                    id: "tbl_1",
+                    sdkName: "orders",
+                    fields: [
+                        { id: "fld_1", sdkName: "total", definition: { type: "number" } },
+                    ],
+                },
+            ],
+        };
+        const result = normalizeSchemaNames(schema);
+        expect(result.renames).toEqual([]);
+        expect(result.schema).toEqual(schema);
+    });
+    // A schema committed before allocation existed. The sandbox's boot-time
+    // `zitejs generate` reads it with no generateSchema pass in front, so this is
+    // the only thing standing between it and a TS1117 it cannot build past.
+    it("repairs a committed schema that already holds the collision", () => {
+        const source = generateDbTs({
+            tables: [
+                { id: "tbl_1", sdkName: "notifications", fields: [] },
+                { id: "tbl_2", sdkName: "orders", fields: [] },
+            ],
+        });
+        const keys = ziteKeys(source);
+        expect(new Set(keys).size).toBe(keys.length);
+        expect(keys).toContain("notifications2");
+    });
+});

package/package.json

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