zitejs 0.9.94 → 0.9.95

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

@@ -30,9 +30,17 @@ export declare const useSession: () => {
         query?: import("better-auth").SessionQueryParams;
     } | undefined) => Promise<void>;
 };
+/**
+ * `loginWithRedirect` and `logout` are returned as well as exported. The
+ * pre-monorepo `useAuth()` returned them, so app code that destructures them
+ * from the hook is common — and returning them here means the legacy compat
+ * shim is the only thing that has to know that, not every migrated app.
+ */
 export declare function useAuth(): {
     user: User | null;
     isLoading: boolean;
+    loginWithRedirect: typeof loginWithRedirect;
+    logout: typeof logout;
 };
 export declare const signIn: {
     magicLink: <FetchOptions extends import("better-auth").ClientFetchOption<Partial<{
@@ -239,17 +247,28 @@ export declare function updateProfile(data: {
         statusText: string;
     };
 }>;
-export type User = {
+/**
+ * An `interface`, not a type alias, so a migrated app can widen it by
+ * declaration merging (`.zite/user-extensions.d.ts`). A legacy user-sync app's
+ * code reads arbitrary columns off the synced row; those can't be enumerated
+ * here, and a type alias can't be reopened to admit them.
+ *
+ * `firstName`/`lastName` are optional rather than `string | null`: the
+ * pre-monorepo User declared them optional, so `{ firstName?: string }` is the
+ * shape existing app code is written against. The producers normalize null to
+ * undefined — see `authTablesService` and the workflow-runner's sync branch.
+ */
+export interface User {
     id: string;
     name: string;
-    firstName: string | null;
-    lastName: string | null;
+    firstName?: string;
+    lastName?: string;
     email: string;
     emailVerified: boolean;
     image: string | null;
     createdAt: Date;
     updatedAt: Date;
-};
+}
 export interface ZiteAuthMethods {
     emailPassword?: boolean;
     magicLink?: boolean;

package/dist/esm/auth/index.js

@@ -13,11 +13,19 @@ const authClient = createAuthClient({
     ],
 });
 export const useSession = authClient.useSession;
+/**
+ * `loginWithRedirect` and `logout` are returned as well as exported. The
+ * pre-monorepo `useAuth()` returned them, so app code that destructures them
+ * from the hook is common — and returning them here means the legacy compat
+ * shim is the only thing that has to know that, not every migrated app.
+ */
 export function useAuth() {
     const { data, isPending } = useSession();
     return {
         user: data?.user ?? null,
         isLoading: isPending,
+        loginWithRedirect,
+        logout,
     };
 }
 export const signIn = authClient.signIn;

package/dist/esm/auth-server/index.d.ts

@@ -1,9 +1,10 @@
+/** Must agree with `User` in `zitejs/auth` and `AuthUser` in `zitejs/runtime`. */
 export interface ZiteAuthUser {
     id: string;
     email: string;
     name: string;
-    firstName: string;
-    lastName: string;
+    firstName?: string;
+    lastName?: string;
 }
 import type { ZiteAuthMethods } from '../auth/index.js';
 export type { ZiteAuthMethods };

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

@@ -11,38 +11,62 @@ export interface ZiteRequestContext {
     };
     userId?: string;
     organizationId?: string;
-    [key: string]: unknown;
-}
-export interface ZiteScheduledContext extends ZiteRequestContext {
-    scheduledAt: string;
 }
+/**
+ * Context on a scheduled (cron-fired) run. There is no authenticated user —
+ * the workflow-runner sends `{ user: null }` literally, because a cron trigger
+ * is an internal call with no session. Only endpoints that declare a `schedule`
+ * see this in their context union, so plain endpoints keep a non-null user.
+ */
+export type ZiteScheduledContext = {
+    user: null;
+};
+export type ZiteErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "CONFLICT" | "RATE_LIMITED" | "INTERNAL_ERROR";
+/**
+ * Throw to fail an endpoint with a specific HTTP status. The worker maps `code`
+ * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
+ * nothing else, so an error carrying only a numeric `statusCode` fell through
+ * to a generic 500.
+ */
 export declare class ZiteError extends Error {
-    statusCode: number;
-    constructor(message: string, options?: {
-        statusCode?: number;
+    code: ZiteErrorCode;
+    constructor(options: {
+        code: ZiteErrorCode;
+        message: string;
     });
 }
-type SchemaLike<T> = {
-    _output: T;
-    parse: (data: unknown) => T;
+/**
+ * Structurally matches a zod schema. `TIn` is the schema's *input* type, which
+ * differs from its output wherever a field has a default or a transform —
+ * `z.number().default(10)` accepts `undefined` but produces `number`.
+ */
+type SchemaLike<TOut, TIn = TOut> = {
+    _output: TOut;
+    _input: TIn;
+    parse: (data: unknown) => TOut;
 };
 export type ZiteStreamInterface = {
     write: (data: unknown) => Promise<void>;
     forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false> {
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput> {
     description?: string;
-    inputSchema?: SchemaLike<TInput>;
+    inputSchema?: SchemaLike<TInput, TRawInput>;
     outputSchema?: SchemaLike<TOutput>;
     stream?: TStream;
     authenticated?: boolean;
-    schedule?: ZiteSchedule;
+    /**
+     * When set, the endpoint also fires on this cron schedule. It stays
+     * request-callable — a schedule is an additional trigger, not a replacement.
+     * Declaring one widens `context` so `context.user` must be null-checked.
+     */
+    schedule?: TSchedule;
     webhook?: ZiteWebhook;
     execute: (params: {
         input: TInput;
-        context: ZiteRequestContext | ZiteScheduledContext;
+        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
     } : {})) => Promise<TOutput> | TOutput;
 }
-export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false>(config: EndpointConfig<TInput, TOutput, TStream>): EndpointConfig<TInput, TOutput, TStream>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TRawInput>;

package/dist/esm/backend/index.js

@@ -1,9 +1,15 @@
+/**
+ * Throw to fail an endpoint with a specific HTTP status. The worker maps `code`
+ * through a fixed table (BAD_REQUEST -> 400, and so on); it reads `code` and
+ * nothing else, so an error carrying only a numeric `statusCode` fell through
+ * to a generic 500.
+ */
 export class ZiteError extends Error {
-    statusCode;
-    constructor(message, options) {
-        super(message);
+    code;
+    constructor(options) {
+        super(options.message);
         this.name = "ZiteError";
-        this.statusCode = options?.statusCode ?? 500;
+        this.code = options.code;
     }
 }
 export function createEndpoint(config) {

package/dist/esm/bundle/index.js

@@ -174,6 +174,19 @@ function getSdkImportSource(baseDir) {
     }
     return 'zite-integrations-backend-sdk';
 }
+/**
+ * `zitejs/db`, `zitejs/api`, `zitejs/integrations` and `zitejs/email` are
+ * tsconfig aliases onto generated files, not real package subpaths — they are
+ * absent from the `exports` map, and `zitejs` isn't in PREBUNDLED_LIBS either.
+ * So marking one external doesn't defer resolution, it guarantees a module
+ * that fails to instantiate the first time the deployed endpoint is invoked,
+ * long after the build reported success. Fail here instead, where the message
+ * can name the file that's missing.
+ */
+const unresolvedAlias = (specifier, expectedPath) => {
+    throw new Error(`Cannot resolve '${specifier}': expected generated file at ${expectedPath}. ` +
+        `Run \`npx zitejs generate\` before bundling.`);
+};
 function createAliasPlugin(opts) {
     return {
         name: 'zite-alias',
@@ -198,7 +211,7 @@ function createAliasPlugin(opts) {
                         if (sdkPath)
                             return { path: sdkPath };
                     }
-                    return { path: 'zitejs/backend', external: true };
+                    return unresolvedAlias(args.path, `${opts.baseDir}/.zite/backend.ts`);
                 });
             }
             // Resolve zitejs/db to .zite/db.ts — check app dir first, then
@@ -212,7 +225,18 @@ function createAliasPlugin(opts) {
                     if (fs.existsSync(rootDbPath))
                         return { path: rootDbPath };
                 }
-                return { path: 'zitejs/db', external: true };
+                return unresolvedAlias('zitejs/db', `${opts.baseDir}/.zite/db.ts or the project root's`);
+            });
+            // Resolve zitejs/api to the app's generated endpoint callers. Endpoints
+            // calling other endpoints is a supported shape — `createCaller` has a
+            // server-side branch that dials the runner directly.
+            build.onResolve({ filter: /^zitejs\/api$/ }, () => {
+                if (opts.baseDir) {
+                    const apiPath = path.resolve(opts.baseDir, '.zite/api.ts');
+                    if (fs.existsSync(apiPath))
+                        return { path: apiPath };
+                }
+                return unresolvedAlias('zitejs/api', `${opts.baseDir}/.zite/api.ts`);
             });
             // Resolve zitejs/integrations to .zite/integrations/airtable.ts
             build.onResolve({ filter: /^zitejs\/integrations$/ }, () => {
@@ -221,7 +245,7 @@ function createAliasPlugin(opts) {
                     if (fs.existsSync(intPath))
                         return { path: intPath };
                 }
-                return { path: 'zitejs/integrations', external: true };
+                return unresolvedAlias('zitejs/integrations', `${opts.baseDir}/.zite/integrations/airtable.ts`);
             });
             // Resolve zitejs/email to .zite/integrations/email.ts
             build.onResolve({ filter: /^zitejs\/email$/ }, () => {
@@ -230,7 +254,7 @@ function createAliasPlugin(opts) {
                     if (fs.existsSync(intPath))
                         return { path: intPath };
                 }
-                return { path: 'zitejs/email', external: true };
+                return unresolvedAlias('zitejs/email', `${opts.baseDir}/.zite/integrations/email.ts`);
             });
             // zitejs/auth/server is types + an identity wrapper — inline a shim so
             // zite.auth.ts bundles without resolving the installed package.

package/dist/esm/check/index.js

@@ -23,6 +23,36 @@ function run(cmd, cwd) {
         return { ok: false, output: (e.stderr ?? '') + (e.stdout ?? '') };
     }
 }
+/**
+ * `zitejs bundle` reports per-endpoint failures inside its JSON payload and
+ * still exits 0, so a non-empty `endpointErrors` is the only signal there is.
+ */
+function bundleFailures(output) {
+    const line = output
+        .trim()
+        .split('\n')
+        .reverse()
+        .find(l => l.startsWith('{'));
+    if (!line)
+        return ['bundle produced no result'];
+    let result;
+    try {
+        result = JSON.parse(line);
+    }
+    catch {
+        return [`could not parse bundle output: ${line.slice(0, 200)}`];
+    }
+    const failures = [];
+    if (result.error)
+        failures.push(result.error);
+    for (const [name, err] of Object.entries(result.endpointErrors ?? {})) {
+        failures.push(`${name}: ${err}`);
+    }
+    if (result.authHooksError) {
+        failures.push(`zite.auth.ts: ${result.authHooksError}`);
+    }
+    return failures;
+}
 export async function runCheck() {
     const appDirs = findAppDirs();
     if (appDirs.length === 0) {
@@ -33,11 +63,19 @@ export async function runCheck() {
     for (const app of appDirs) {
         const appPath = join('apps', app);
         console.log(`\n── ${app} ──`);
+        // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
+        // solution-style config — `"files": []` plus a reference — so
+        // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It
+        // used to be the fallback, which meant an app missing tsconfig.app.json
+        // reported a passing typecheck it never ran.
         const tsconfigAppPath = join(appPath, 'tsconfig.app.json');
-        const tsconfigPath = existsSync(tsconfigAppPath) ? tsconfigAppPath : join(appPath, 'tsconfig.json');
-        if (existsSync(tsconfigPath)) {
+        if (!existsSync(tsconfigAppPath)) {
+            console.log(`  tsc --noEmit ... ✗ (no ${tsconfigAppPath})`);
+            allPassed = false;
+        }
+        else {
             process.stdout.write('  tsc --noEmit ... ');
-            const tsc = run(`npx tsc --noEmit -p ${tsconfigPath}`, '.');
+            const tsc = run(`npx tsc --noEmit -p ${tsconfigAppPath}`, '.');
             if (tsc.ok) {
                 console.log('✓');
             }
@@ -47,6 +85,22 @@ export async function runCheck() {
                 allPassed = false;
             }
         }
+        // Endpoints never reach vite — they are bundled separately for the lambda,
+        // against a different resolver. tsc and vite both pass on an endpoint whose
+        // `zitejs/*` alias has no generated file behind it; only the bundler knows.
+        if (existsSync(join(appPath, 'src', 'api'))) {
+            process.stdout.write('  bundle endpoints ... ');
+            const bundle = run(`npx zitejs bundle --app ${app}`, '.');
+            const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];
+            if (failures.length === 0) {
+                console.log('✓');
+            }
+            else {
+                console.log('✗');
+                console.log(failures.map(l => `    ${l}`).join('\n'));
+                allPassed = false;
+            }
+        }
         const viteConfig = join(appPath, 'vite.config.ts');
         if (existsSync(viteConfig)) {
             process.stdout.write('  vite build ... ');

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

@@ -1,11 +1,37 @@
 import type { NotificationsCreateParams, NotificationsCreateResult } from "../notifications/index.js";
-export interface TableFindAllOptions {
+/**
+ * A comparison against one field. Mirrors base-runner's operator set
+ * (`LegacyWhereConditionOperators`); anything else in the object is ignored.
+ */
+export type FilterCondition<V> = {
+    /** Substring match (text fields) or "has any of these" (linked records). */
+    contains?: V extends Array<infer E> ? E | E[] : V;
+    /** Not equal, or — against `null` — "is set". */
+    not?: V | null;
+    /** Empty array means "no filter", not "match nothing". */
+    in?: V extends Array<infer E> ? E[] : V[];
+    /** Empty array means "no filter", not "match everything". */
+    notIn?: V extends Array<infer E> ? E[] : V[];
+    lt?: V;
+    lte?: V;
+    gt?: V;
+    gte?: V;
+};
+/**
+ * Filters keyed by the record's own field names. Typed rather than `unknown`
+ * because an unrecognized key is not an error at runtime — it passes through
+ * the SDK-name-to-field-id transform verbatim, matches no column, and the query
+ * comes back **unfiltered**. A typo silently returns every row.
+ */
+export type RecordFilters<T> = {
+    [K in keyof T]?: T[K] | FilterCondition<T[K]>;
+};
+export interface TableFindAllOptions<T = Record<string, unknown>> {
     limit?: number;
     offset?: number;
     sort?: unknown[];
-    filter?: unknown;
-    filters?: unknown;
-    fields?: string[];
+    filters?: RecordFilters<T>;
+    fields?: Array<Extract<keyof T, string>>;
 }
 export interface BulkCreateResult<T> {
     success: boolean;
@@ -16,34 +42,40 @@ export interface UpdateResult<T> {
     fields: Partial<T>;
 }
 export interface DeleteResult {
+    success: true;
     id: string;
 }
-export interface TableClient<T> {
-    findAll(params?: TableFindAllOptions): Promise<{
+/**
+ * `TInput` is the record's *write* shape, which is not `T`: computed fields
+ * can't be written, and several field types accept looser input than they
+ * store. Defaults to `T` so a hand-written `TableClient<Foo>` still compiles.
+ */
+export interface TableClient<T, TInput = T> {
+    findAll(params?: TableFindAllOptions<T>): Promise<{
         records: T[];
         hasMore: boolean;
     }>;
     findOne(params: {
         id?: string;
-        filters?: unknown;
-        fields?: string[];
+        filters?: RecordFilters<T>;
+        fields?: Array<Extract<keyof T, string>>;
     }): Promise<T | undefined>;
     create(params: {
-        record: Partial<T>;
+        record: Partial<TInput>;
     }): Promise<T>;
     update(params: {
         id: string;
-        record: Partial<T>;
+        record: Partial<TInput>;
     }): Promise<UpdateResult<T>>;
     delete(params: {
         id: string;
     }): Promise<DeleteResult>;
     bulkCreate(params: {
-        records: Partial<T>[];
+        records: Partial<TInput>[];
         matchOn?: string[];
     }): Promise<BulkCreateResult<T>>;
 }
-export declare function createTableClient<T>(className: string): TableClient<T>;
+export declare function createTableClient<T, TInput = T>(className: string): TableClient<T, TInput>;
 export interface SqlResult {
     rows: Record<string, unknown>[];
     columns: Array<{
@@ -57,15 +89,16 @@ export declare function createSqlClient(): (params: {
     query: string;
     params?: unknown[];
 }) => Promise<SqlResult>;
+/** Must agree with `User` in `zitejs/auth` and `ZiteAuthUser` in `zitejs/auth-server` — the three used to disagree on whether the name fields were nullable or optional. */
 export interface AuthUser {
     id: string;
     name: string;
     email: string;
-    firstName: string | null;
-    lastName: string | null;
+    firstName?: string;
+    lastName?: string;
     image: string | null;
 }
-export type FindAllAuthUsersOptions = Omit<TableFindAllOptions, "fields"> & {
+export type FindAllAuthUsersOptions = Omit<TableFindAllOptions<AuthUser>, "fields"> & {
     /** Restrict results to users belonging to any of these apps. */
     appIds?: string[];
 };
@@ -80,11 +113,13 @@ export interface AuthClient<T extends AuthUser = AuthUser> {
     updateUserProfile(userId: string, profile: UpdateAuthUserProfile): Promise<T>;
 }
 export declare function createAuthClient<T extends AuthUser = AuthUser>(): AuthClient<T>;
-export interface AirtableTableClient<T> {
+/** `TInput` is the record's write shape — see `TableClient` for why it isn't `T`. */
+export interface AirtableTableClient<T, TInput = T> {
     findAll(params?: {
+        /** An opaque cursor from a previous call — not a row count. */
         offset?: string;
         limit?: number;
-        filters?: unknown;
+        filters?: RecordFilters<T>;
     }): Promise<{
         records: T[];
         offset: string | undefined;
@@ -92,17 +127,17 @@ export interface AirtableTableClient<T> {
     }>;
     findOne(params: {
         id?: string;
-        filters?: unknown;
+        filters?: RecordFilters<T>;
     }): Promise<T | undefined>;
     create(params: {
-        record: Partial<T>;
+        record: Partial<TInput>;
     }): Promise<T>;
     bulkCreate(params: {
-        records: Partial<T>[];
+        records: Partial<TInput>[];
     }): Promise<T[]>;
     update(params: {
         id: string;
-        record: Partial<T>;
+        record: Partial<TInput>;
     }): Promise<{
         id: string;
         fields: Partial<T>;
@@ -111,7 +146,7 @@ export interface AirtableTableClient<T> {
         id: string;
     }): Promise<DeleteResult>;
 }
-export declare function createAirtableClient<T>(integrationId: string, className: string, implicitParams: Record<string, unknown>): AirtableTableClient<T>;
+export declare function createAirtableClient<T, TInput = T>(integrationId: string, className: string, implicitParams: Record<string, unknown>): AirtableTableClient<T, TInput>;
 /** A block of content in an email body. */
 export type EmailBlock = {
     type: "text";