zitejs 0.9.114 → 0.9.116

package/dist/esm/bundle/index.js

@@ -57,6 +57,8 @@ const PREBUNDLED_LIBS = {
     'intercom-client': '__intercom__.js',
     '@google/generative-ai': '__gemini__.js',
     '@elevenlabs/elevenlabs-js': '__elevenlabs__.js',
+    'resend': '__resend__.js',
+    '@clickhouse/client-web': '__clickhouse__.js',
 };
 export const BASE_BUILD_OPTIONS = {
     bundle: true,

package/dist/esm/runtime/index.js

@@ -1,5 +1,77 @@
 import { getSdkCall } from "../internal/sdkCall.js";
 const DB_INTEGRATION_ID = "databases";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Not thrown — the miss is the answer. Logged so the author can still find out
+ * their value was missing, since a silent null looks exactly like a legitimate
+ * no-match and would otherwise hide the bug that caused it.
+ */
+function warnEmptySelector(className, method, detail) {
+    console.warn(`${className}.${method}: ${detail} is undefined, so this query would have ` +
+        "run unnarrowed and returned an arbitrary record. Returning no match " +
+        "instead. Check the value before querying, or pass null to match " +
+        "records where the field is empty.");
+}
+/**
+ * Whether a selector was written with nothing in it.
+ *
+ * `JSON.stringify` drops an undefined value, so `{ filters: { token: undefined } }`
+ * reaches base-runner as `{ filters: {} }` — a valid request for no filter.
+ * `findOne` answers that with the first row of the table, and the caller reads
+ * it back as a match.
+ *
+ * `findOne` treats it as "matched nothing" instead, which is what asking for
+ * `token === undefined` should mean. Callers already handle the miss —
+ * `if (!row) return { status: 'invalid_token' }` — so the shape that caused the
+ * incident becomes correct on its own, with no app change and nothing to break.
+ *
+ * **`findOne` only.** On `findAll`, "no filter" is a coherent request, and
+ * `filters: { status: maybeUndefined }` meaning "don't narrow on status" is an
+ * idiom that type-checks today (`RecordFilters` is a `?:` map, and apps build
+ * without `exactOptionalPropertyTypes`). It is also what Prisma does with
+ * `undefined` in a `where`. Only `findOne` has no sane reading, because an
+ * unnarrowed single-row query returns an arbitrary record rather than everything.
+ *
+ * A key the caller never wrote is untouched: `findOne({ filters: {} })` still
+ * means "no filter" and still returns the first row. Only a key written with
+ * nothing in it counts. (Unknown filter keys have the same consequence — see
+ * `RecordFilters` — but those are `keyof T` and caught at build time.)
+ */
+function selectorMatchesNothing(className, method, params) {
+    if (!params)
+        return false;
+    const { filters } = params;
+    if (isPlainObject(filters)) {
+        for (const [key, value] of Object.entries(filters)) {
+            if (value === undefined) {
+                warnEmptySelector(className, method, `filter "${key}"`);
+                return true;
+            }
+            // `{ field: { contains: undefined } }` collapses to `{ field: {} }` — no
+            // condition on that field at all.
+            if (isPlainObject(value)) {
+                for (const [operator, operand] of Object.entries(value)) {
+                    if (operand === undefined) {
+                        warnEmptySelector(className, method, `filter "${key}.${operator}"`);
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    // An undefined `id` leaves the query with no selector at all. Only counts
+    // when nothing else narrows it, so `findOne({ id: maybeId, filters: {...} })`
+    // still runs on the filters.
+    const wroteId = Object.prototype.hasOwnProperty.call(params, "id");
+    const hasFilters = isPlainObject(filters) && Object.keys(filters).length > 0;
+    if (wroteId && params.id === undefined && !hasFilters) {
+        warnEmptySelector(className, method, "`id`");
+        return true;
+    }
+    return false;
+}
 function getBaseId() {
     try {
         return (globalThis.__ZITE_EXECUTION_CONFIG__?.baseId ??
@@ -26,16 +98,22 @@ function resolveTableId(className) {
 }
 export function createTableClient(className) {
     return {
-        findAll: (params) => getSdkCall()(DB_INTEGRATION_ID, className, "findAll", {
-            baseId: getBaseId(),
-            tableId: resolveTableId(className),
-            ...params,
-        }),
-        findOne: (params) => getSdkCall()(DB_INTEGRATION_ID, className, "findOne", {
-            baseId: getBaseId(),
-            tableId: resolveTableId(className),
-            ...params,
-        }),
+        findAll: async (params) => {
+            return getSdkCall()(DB_INTEGRATION_ID, className, "findAll", {
+                baseId: getBaseId(),
+                tableId: resolveTableId(className),
+                ...params,
+            });
+        },
+        findOne: async (params) => {
+            if (selectorMatchesNothing(className, "findOne", params))
+                return undefined;
+            return getSdkCall()(DB_INTEGRATION_ID, className, "findOne", {
+                baseId: getBaseId(),
+                tableId: resolveTableId(className),
+                ...params,
+            });
+        },
         create: (params) => getSdkCall()(DB_INTEGRATION_ID, className, "create", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
@@ -66,10 +144,12 @@ export function createSqlClient() {
 }
 export function createAuthClient() {
     return {
-        findAllUsers: (options) => getSdkCall()(DB_INTEGRATION_ID, "Auth", "findAllUsers", {
-            baseId: getBaseId(),
-            ...options,
-        }),
+        findAllUsers: async (options) => {
+            return getSdkCall()(DB_INTEGRATION_ID, "Auth", "findAllUsers", {
+                baseId: getBaseId(),
+                ...options,
+            });
+        },
         updateUserProfile: (userId, profile) => getSdkCall()(DB_INTEGRATION_ID, "Auth", "updateUserProfile", {
             baseId: getBaseId(),
             userId,
@@ -79,14 +159,20 @@ export function createAuthClient() {
 }
 export function createAirtableClient(integrationId, className, implicitParams) {
     return {
-        findAll: (params) => getSdkCall()(integrationId, className, "findAll", {
-            ...implicitParams,
-            ...params,
-        }),
-        findOne: (params) => getSdkCall()(integrationId, className, "findOne", {
-            ...implicitParams,
-            ...params,
-        }),
+        findAll: async (params) => {
+            return getSdkCall()(integrationId, className, "findAll", {
+                ...implicitParams,
+                ...params,
+            });
+        },
+        findOne: async (params) => {
+            if (selectorMatchesNothing(className, "findOne", params))
+                return undefined;
+            return getSdkCall()(integrationId, className, "findOne", {
+                ...implicitParams,
+                ...params,
+            });
+        },
         create: (params) => getSdkCall()(integrationId, className, "create", {
             ...implicitParams,
             ...params,

package/dist/esm/runtime/index.test.d.ts

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

package/dist/esm/runtime/index.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { createTableClient, createAirtableClient, createAuthClient, } from "./index.js";
+/** Captures what the runtime would have dispatched to the workflow-runner. */
+function stubSdkCall(result = undefined) {
+    const calls = [];
+    vi.stubGlobal("__wrapSdkCall", async (_integrationId, _className, method, params) => {
+        calls.push({ method, params });
+        return result;
+    });
+    return calls;
+}
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+describe("the mechanism", () => {
+    it("drops an undefined filter value on serialization, leaving an unfiltered read", () => {
+        const token = undefined;
+        const wire = JSON.stringify({ filters: { tokenFraisAdmin: token } });
+        expect(wire).toBe('{"filters":{}}');
+        expect(JSON.parse(wire).filters).toEqual({});
+    });
+});
+describe("findOne", () => {
+    it("matches nothing when a filter value is undefined, without dispatching", async () => {
+        // The incident shape. `if (!row) return { status: 'invalid_token' }` is
+        // what callers already write, so answering "no match" makes that code
+        // correct on its own — where returning the first row made it lie.
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        const token = undefined;
+        const row = await clients.findOne({
+            filters: { tokenFraisAdmin: token },
+        });
+        expect(row).toBeUndefined();
+        expect(calls).toHaveLength(0);
+    });
+    it("warns so a missing value is still discoverable in the run log", async () => {
+        // A silent miss looks exactly like a legitimate no-match, which would hide
+        // the bug that produced it.
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        stubSdkCall();
+        const clients = createTableClient("Clients");
+        await clients.findOne({ filters: { tokenFraisAdmin: undefined } });
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining('filter "tokenFraisAdmin" is undefined'));
+        warn.mockRestore();
+    });
+    it("matches nothing on an undefined operand inside a filter condition", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        const row = await clients.findOne({
+            filters: { nom: { contains: undefined } },
+        });
+        expect(row).toBeUndefined();
+        expect(calls).toHaveLength(0);
+    });
+    it("matches nothing on an undefined id when nothing else narrows the query", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        const id = undefined;
+        const row = await clients.findOne({ id });
+        expect(row).toBeUndefined();
+        expect(calls).toHaveLength(0);
+    });
+    it("still allows an undefined id when filters narrow the query", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        await clients.findOne({ id: undefined, filters: { nom: "Henry" } });
+        expect(calls).toHaveLength(1);
+    });
+    it("still allows a deliberate unfiltered lookup", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        await clients.findOne({ filters: {} });
+        await clients.findOne({});
+        expect(calls).toHaveLength(2);
+    });
+    it("passes real values through untouched", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        await clients.findOne({ filters: { tokenFraisAdmin: "b69779ae-eeea" } });
+        expect(calls[0]?.params).toMatchObject({
+            filters: { tokenFraisAdmin: "b69779ae-eeea" },
+        });
+    });
+    it("allows null, which means the field is empty", async () => {
+        const calls = stubSdkCall();
+        const clients = createTableClient("Clients");
+        await clients.findOne({ filters: { nom: { not: null } } });
+        expect(calls).toHaveLength(1);
+    });
+});
+describe("findAll", () => {
+    it("treats an undefined filter value as 'do not narrow on this'", async () => {
+        // Deliberately NOT guarded, unlike findOne. On a list query "no filter" is
+        // a coherent request, `filters: { x: maybeUndefined }` type-checks today,
+        // and this is what Prisma does with undefined in a `where`. The dangerous
+        // reading is findOne's, where an unnarrowed query returns an arbitrary row
+        // that the caller treats as a match.
+        const calls = stubSdkCall({ records: [], hasMore: false });
+        const clients = createTableClient("Clients");
+        await clients.findAll({ filters: { tokenFraisAdmin: undefined } });
+        expect(calls).toHaveLength(1);
+    });
+    it("still allows listing a whole table on purpose", async () => {
+        const calls = stubSdkCall({ records: [], hasMore: false });
+        const clients = createTableClient("Clients");
+        await clients.findAll();
+        await clients.findAll({ limit: 10 });
+        expect(calls).toHaveLength(2);
+    });
+});
+describe("other clients on the same path", () => {
+    it("guards the Airtable client", async () => {
+        const calls = stubSdkCall();
+        const table = createAirtableClient("airtable", "Clients", {
+            baseId: "app1",
+            tableId: "tbl1",
+        });
+        const row = await table.findOne({
+            filters: { tokenFraisAdmin: undefined },
+        });
+        expect(row).toBeUndefined();
+        expect(calls).toHaveLength(0);
+    });
+    it("leaves auth user lookups alone, as a findAll", async () => {
+        const calls = stubSdkCall({ records: [], total: 0, hasMore: false });
+        const auth = createAuthClient();
+        await auth.findAllUsers({ filters: { email: undefined } });
+        expect(calls).toHaveLength(1);
+    });
+});

package/dist/esm/sync/lib.js

@@ -528,6 +528,7 @@ export function generateDbTs(inputSchema) {
     lines.push('//       `not: null` means "is set". An empty `in: []` matches nothing; an', "//       empty `notIn: []` applies no filter.");
     lines.push("//     sort is currently IGNORED here — it is stripped before the request.", "//       (it does work on zite.auth.findAllUsers). Order in SQL instead.");
     lines.push("//     limit defaults to 500, max 2000; offset is a row count (a number)");
+    lines.push('//     a filter value of `undefined` is REJECTED (it would query unfiltered', '//       and match an arbitrary record). Check the value first.');
     lines.push("//   .findOne({ id?, filters?, fields? }) → T | undefined");
     lines.push("//   .create({ record }) → T");
     lines.push("//   .update({ id, record }) → { id: string, fields: Partial<T> }");
@@ -1144,6 +1145,13 @@ export function generateAirtableTs(inputLock) {
         "// Auto-generated by zitejs generate from zite.lock. Do not edit manually.",
         "// Airtable SDK — uses createAirtableClient from zitejs/runtime.",
         "//",
+        "// Usage in endpoint files (src/api/*.ts) — one client is exported per table:",
+        `//   import { ${lock.tables[0]?.sdkName ?? "TableName"} } from 'zitejs/integrations';`,
+        "//",
+        "// Always use 'zitejs/integrations' — never a relative path like",
+        "// '../../.zite/integrations/airtable'. The tsconfig aliases resolve zitejs/*",
+        "// imports to the correct .zite/ files.",
+        "//",
         "// Each exported table client has these methods (all take a single params object):",
         "//   findAll({ offset?, limit?, filters? }) => { records: T[], offset: string | undefined, hasMore: boolean }",
         "//   findOne({ id?, filters? }) => T | undefined",
@@ -1361,6 +1369,12 @@ export function generateEmailSdk(integrationId) {
         "// Auto-generated by zitejs generate from zite.config.json. Do not edit manually.",
         "// Email SDK — sends through the Zite email gateway via the runtime bridge.",
         "//",
+        "// Usage in endpoint files (src/api/*.ts):",
+        "//   import { Email } from 'zitejs/email';",
+        "//",
+        "// Always use 'zitejs/email' — never a relative path like '../../.zite/integrations/email'.",
+        "// The tsconfig aliases resolve zitejs/* imports to the correct .zite/ files.",
+        "//",
         "//   await Email.send({ to, subject, body: [{ type: 'text', content: '...' }] })",
         "//     => { success: boolean; messageId: string }",
         "//",

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

@@ -25,7 +25,8 @@ 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").
+ * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey"), and
+ * folding a diacritic into its base letter: "Filières" -> "filieres".
  *
  * Deliberately not folded into toCamelCase: that also derives endpoint
  * identifiers from existing filenames on every generate, where normalizing

package/dist/esm/sync/sdkNames.js

@@ -40,7 +40,8 @@ export function toCamelCase(name) {
 }
 /**
  * camelCase for a FRESH sdkName, reading acronym runs as words: "VIP" ->
- * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey").
+ * "vip", "APIKey" -> "apiKey" (plain toCamelCase yields "vIP" / "aPIKey"), and
+ * folding a diacritic into its base letter: "Filières" -> "filieres".
  *
  * Deliberately not folded into toCamelCase: that also derives endpoint
  * identifiers from existing filenames on every generate, where normalizing
@@ -48,7 +49,22 @@ export function toCamelCase(name) {
  * chosen for the first time — generateSchema preserves existing sdkNames.
  */
 export function toSdkName(name) {
+    // Decompose, then drop the combining marks, so an accented letter keeps its
+    // base rather than being read as punctuation. `toPascalCase` treats anything
+    // outside [a-zA-Z0-9] as a word separator and uppercases what follows it, so
+    // without this a table called "Fiches Filières" allocates `fichesFiliRes`.
+    //
+    // The bar is not "looks nicer" — it is Zite 1.0, which sanitised names this
+    // exact way (`getIntegrationNameMapping`) and therefore allocated
+    // `fichesFilieres`. Every app carried over from 1.0 compiles against that
+    // name, so a generator that disagrees hands a non-English base an accessor
+    // nobody would write and nothing resolves to.
+    //
+    // Only Latin diacritics fold. A name with no ASCII letters at all (Cyrillic,
+    // CJK, emoji) still collapses to `_` here, exactly as it did in 1.0.
     const deAcronymed = name
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
         .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);

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

@@ -233,3 +233,51 @@ describe("table display names", () => {
         expect(schema.tables[0].name).toBe("Deals");
     });
 });
+/**
+ * `toPascalCase` reads anything outside [a-zA-Z0-9] as a word separator and
+ * uppercases what follows, so an accent used to split the word it sat inside:
+ * "Filières" -> `filiRes`. Zite 1.0 stripped the combining mark instead, and
+ * every app carried over from it compiles against THAT name — so this is a
+ * disagreement with the apps in the wild, not a cosmetic preference.
+ */
+describe("diacritics in a fresh sdkName", () => {
+    const nameFor = (tableName) => generateSchema(database([{ id: "tbl_1", name: tableName, fields: [] }]))
+        .tables[0].sdkName;
+    it.each([
+        ["Fiches Filières", "fichesFilieres"],
+        ["Recherches Métiers", "recherchesMetiers"],
+        ["Profil Compétences", "profilCompetences"],
+        ["Café Menu", "cafeMenu"],
+        ["Señor Clients", "senorClients"],
+        // Real, from a migrated base: an all-caps name where the accent sits inside
+        // an acronym run, so the de-acronym pass has to see the folded letter.
+        ["XICOH TRÁMITES", "xicohTramites"],
+    ])("folds %s into %s", (display, sdkName) => {
+        expect(nameFor(display)).toBe(sdkName);
+    });
+    it("folds a field name the same way", () => {
+        const schema = generateSchema(database([
+            {
+                id: "tbl_1",
+                name: "Trámites",
+                fields: [field("fld_1", "Horario de Atención")],
+            },
+        ]));
+        expect(schema.tables[0].fields[0].sdkName).toBe("horarioDeAtencion");
+    });
+    it("leaves a name with no ASCII letters degenerate, as 1.0 did", () => {
+        // NFD only folds Latin diacritics. Nothing here to fold onto, so this
+        // collapses exactly as before — called out so the narrower scope is a
+        // decision on the record rather than an oversight.
+        expect(nameFor("Посещения")).toBe("_");
+    });
+    it("does not rename a table already locked to the old spelling", () => {
+        // The whole point of the lock: an app compiling against `fichesFiliRes`
+        // keeps it. Only names allocated from here on change.
+        const existingSchema = {
+            tables: [{ id: "tbl_1", sdkName: "fichesFiliRes", fields: [] }],
+        };
+        const schema = generateSchema(database([{ id: "tbl_1", name: "Fiches Filières", fields: [] }]), existingSchema);
+        expect(schema.tables[0].sdkName).toBe("fichesFiliRes");
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zitejs",
-  "version": "0.9.114",
-  "description": "The Zite framework — build apps on Zite Database",
+  "version": "0.9.116",
+  "description": "The Zite framework \u2014 build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",

package/dist/cjs/api/index.js

@@ -1,5 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-"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/esm/api/index.d.ts

@@ -1,2 +0,0 @@
-export { createCaller } from '../caller/index.js';
-export type { EndpointConfig } from '../caller/index.js';

package/dist/esm/api/index.js

@@ -1 +0,0 @@
-export { createCaller } from '../caller/index.js';

package/dist/esm/db/index.d.ts

@@ -1,2 +0,0 @@
-export { createTableClient } from '../runtime/index.js';
-export type { TableClient } from '../runtime/index.js';

package/dist/esm/db/index.js

@@ -1 +0,0 @@
-export { createTableClient } from '../runtime/index.js';