zitejs 0.9.73 → 0.9.75

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

@@ -0,0 +1,345 @@
+export interface ZiteAuthUser {
+    id: string;
+    email: string;
+    name: string;
+    firstName?: string;
+    lastName?: string;
+}
+export interface ZiteAuthConfig {
+    flowPublicId?: string;
+    onSignup?: (user: ZiteAuthUser) => Promise<void>;
+    onLogin?: (user: ZiteAuthUser) => Promise<void>;
+    beforeSignup?: (email: string) => Promise<boolean>;
+    sendEmail?: (to: string, subject: string, body: string) => Promise<void>;
+}
+export declare function ziteAuth(config?: ZiteAuthConfig): import("better-auth").Auth<{
+    database: {
+        url: string;
+    };
+    secret: string;
+    baseURL: string;
+    advanced: {
+        disableCSRFCheck: true;
+    };
+    rateLimit: {
+        window: number;
+        max: number;
+    };
+    emailAndPassword: {
+        enabled: true;
+    };
+    plugins: [{
+        id: "generic-oauth";
+        version: string;
+        init: (ctx: import("better-auth").AuthContext) => {
+            context: {
+                socialProviders: import("better-auth").OAuthProvider<Record<string, any>, Partial<import("better-auth").ProviderOptions<any>>>[];
+            };
+        };
+        endpoints: {
+            signInWithOAuth2: import("better-auth").StrictEndpoint<"/sign-in/oauth2", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    providerId: import("better-auth").ZodString;
+                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    disableRedirect: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    requestSignUp: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
+                    additionalData: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                url: {
+                                                    type: string;
+                                                };
+                                                redirect: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                url: string;
+                redirect: boolean;
+            }>;
+            oAuth2Callback: import("better-auth").StrictEndpoint<"/oauth2/callback/:providerId", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    code: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    error: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    error_description: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    state: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    iss: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    allowedMediaTypes: string[];
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                url: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    scope: "server";
+                };
+            }, never>;
+            oAuth2LinkAccount: import("better-auth").StrictEndpoint<"/oauth2/link", {
+                method: "POST";
+                body: import("better-auth").ZodObject<{
+                    providerId: import("better-auth").ZodString;
+                    callbackURL: import("better-auth").ZodString;
+                    scopes: import("better-auth").ZodOptional<import("better-auth").ZodArray<import("better-auth").ZodString>>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                url: {
+                                                    type: string;
+                                                    format: string;
+                                                    description: string;
+                                                };
+                                                redirect: {
+                                                    type: string;
+                                                    description: string;
+                                                    enum: boolean[];
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                url: string;
+                redirect: boolean;
+            }>;
+        };
+        options: import("better-auth/plugins").GenericOAuthOptions;
+        $ERROR_CODES: {
+            INVALID_OAUTH_CONFIGURATION: import("better-auth").RawError<"INVALID_OAUTH_CONFIGURATION">;
+            TOKEN_URL_NOT_FOUND: import("better-auth").RawError<"TOKEN_URL_NOT_FOUND">;
+            PROVIDER_CONFIG_NOT_FOUND: import("better-auth").RawError<"PROVIDER_CONFIG_NOT_FOUND">;
+            PROVIDER_ID_REQUIRED: import("better-auth").RawError<"PROVIDER_ID_REQUIRED">;
+            INVALID_OAUTH_CONFIG: import("better-auth").RawError<"INVALID_OAUTH_CONFIG">;
+            SESSION_REQUIRED: import("better-auth").RawError<"SESSION_REQUIRED">;
+            ISSUER_MISMATCH: import("better-auth").RawError<"ISSUER_MISMATCH">;
+            ISSUER_MISSING: import("better-auth").RawError<"ISSUER_MISSING">;
+        };
+    }, {
+        id: "magic-link";
+        version: string;
+        endpoints: {
+            signInMagicLink: import("better-auth").StrictEndpoint<"/sign-in/magic-link", {
+                method: "POST";
+                requireHeaders: true;
+                body: import("better-auth").ZodObject<{
+                    email: import("better-auth").ZodEmail;
+                    name: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    metadata: import("better-auth").ZodOptional<import("better-auth").ZodRecord<import("better-auth").ZodString, import("better-auth").ZodAny>>;
+                }, import("zod/v4/core").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            magicLinkVerify: import("better-auth").StrictEndpoint<"/magic-link/verify", {
+                method: "GET";
+                query: import("better-auth").ZodObject<{
+                    token: import("better-auth").ZodString;
+                    callbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    errorCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                    newUserCallbackURL: import("better-auth").ZodOptional<import("better-auth").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>)[];
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+                session: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                };
+            }>;
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        options: import("better-auth/plugins").MagicLinkOptions;
+    }];
+    user: {
+        modelName: "zite_user";
+        additionalFields: {
+            firstName: {
+                type: "string";
+                required: false;
+            };
+            lastName: {
+                type: "string";
+                required: false;
+            };
+        };
+    };
+    session: {
+        modelName: "zite_session";
+    };
+    account: {
+        modelName: "zite_account";
+    };
+    verification: {
+        modelName: "zite_verification";
+    };
+    databaseHooks: {
+        user: {
+            create: {
+                before: ((user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>) => Promise<undefined>) | undefined;
+                after: ((user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & Record<string, unknown>) => Promise<void>) | undefined;
+            };
+        };
+    };
+}>;

package/dist/cjs/auth-server/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ziteAuth = ziteAuth;
+const better_auth_1 = require("better-auth");
+const plugins_1 = require("better-auth/plugins");
+function ziteAuth(config = {}) {
+    const sendMagicLinkEmail = config.sendEmail
+        ? async ({ email, url }) => {
+            await config.sendEmail(email, 'Sign in to your app', `Click here to sign in: ${url}`);
+        }
+        : async ({ email, url }) => {
+            console.log(`[ziteAuth] Magic link for ${email}: ${url}`);
+        };
+    return (0, better_auth_1.betterAuth)({
+        database: { url: process.env.DATABASE_URL },
+        secret: process.env.ZITE_AUTH_SECRET || 'zite-local-dev-secret',
+        baseURL: 'http://localhost',
+        advanced: { disableCSRFCheck: true },
+        rateLimit: { window: 60, max: 10 },
+        emailAndPassword: { enabled: true },
+        plugins: [
+            (0, plugins_1.genericOAuth)({
+                config: [
+                    {
+                        providerId: 'zite',
+                        clientId: process.env.ZITE_OAUTH_CLIENT_ID,
+                        clientSecret: process.env.ZITE_OAUTH_CLIENT_SECRET,
+                        discoveryUrl: process.env.ZITE_AUTH_URL +
+                            '/.well-known/openid-configuration',
+                    },
+                ],
+            }),
+            (0, plugins_1.magicLink)({ sendMagicLink: sendMagicLinkEmail }),
+        ],
+        user: {
+            modelName: 'zite_user',
+            additionalFields: {
+                firstName: { type: 'string', required: false },
+                lastName: { type: 'string', required: false },
+            },
+        },
+        session: { modelName: 'zite_session' },
+        account: { modelName: 'zite_account' },
+        verification: { modelName: 'zite_verification' },
+        databaseHooks: {
+            user: {
+                create: {
+                    before: config.beforeSignup
+                        ? async (user) => {
+                            const allowed = await config.beforeSignup(user.email);
+                            if (!allowed) {
+                                throw new Error('Signup not allowed for this email');
+                            }
+                            return undefined;
+                        }
+                        : undefined,
+                    after: config.onSignup
+                        ? async (user) => {
+                            await config.onSignup({
+                                id: user.id,
+                                email: user.email,
+                                name: user.name,
+                                firstName: user.firstName,
+                                lastName: user.lastName,
+                            });
+                        }
+                        : undefined,
+                },
+            },
+        },
+    });
+}

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

@@ -1,3 +1,8 @@
+import type { ZiteSchedule } from "../schedules/index.js";
+export type { ZiteSchedule };
+export type ZiteWebhook = {
+    paused?: boolean;
+};
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -31,6 +36,8 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
     outputSchema?: SchemaLike<TOutput>;
     stream?: TStream;
     authenticated?: boolean;
+    schedule?: ZiteSchedule;
+    webhook?: ZiteWebhook;
     execute: (params: {
         input: TInput;
         context: ZiteRequestContext | ZiteScheduledContext;
@@ -39,4 +46,3 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
     } : {})) => 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 {};

package/dist/cjs/caller/index.js

@@ -23,10 +23,17 @@ const ENVIRONMENTS = {
     local: "http://localhost:2506",
 };
 function getRunnerUrl() {
+    const explicit = (0, env_js_1.getEnv)("ZITE_RUNNER_URL", "VITE_ZITE_RUNNER_URL");
+    if (explicit)
+        return explicit;
+    // Published apps use same-origin proxy (/api/*) — the CF worker
+    // forwards to the workflow-runner. This ensures cookies work and
+    // the browser sees a single origin.
+    if (getMode() === "live")
+        return "";
+    // Preview/editor mode: call the workflow-runner directly
     const env = (0, env_js_1.getEnv)("ZITE_ENV", "VITE_ZITE_ENV") ?? "production";
-    return ((0, env_js_1.getEnv)("ZITE_RUNNER_URL", "VITE_ZITE_RUNNER_URL") ??
-        ENVIRONMENTS[env] ??
-        ENVIRONMENTS.production);
+    return ENVIRONMENTS[env] ?? ENVIRONMENTS.production;
 }
 /**
  * Get the user's usage token for endpoint auth.
@@ -49,12 +56,18 @@ function getUsageToken() {
 }
 function buildFetchOptions(name, input, extra) {
     const appId = (0, env_js_1.getEnv)("ZITE_FLOW_ID", "VITE_ZITE_FLOW_ID") ?? "";
+    const runnerUrl = getRunnerUrl();
     const token = getUsageToken();
     const ziteAuthToken = typeof localStorage !== "undefined"
         ? localStorage.getItem("zite.auth.token")
         : null;
+    // Same-origin mode (published apps): /api/{name}
+    // Direct mode (preview): {runnerUrl}/public/{appId}/api/{name}
+    const url = runnerUrl === ""
+        ? "/api/" + name
+        : runnerUrl + "/public/" + appId + "/api/" + name;
     return {
-        url: getRunnerUrl() + "/public/" + appId + "/api/" + name,
+        url,
         init: {
             method: "POST",
             headers: {

package/dist/cjs/dev/index.js

@@ -52,6 +52,18 @@ function getEmailIntegrationId(appDir) {
     catch { }
     return undefined;
 }
+function getDeclaredEnvVarNames(appDir) {
+    try {
+        const configPath = (0, path_1.join)("apps", appDir, "zite.config.json");
+        if (!(0, fs_2.existsSync)(configPath))
+            return [];
+        const config = JSON.parse((0, fs_2.readFileSync)(configPath, "utf-8"));
+        return Object.keys(config.envVars ?? {});
+    }
+    catch {
+        return [];
+    }
+}
 function regenerateAppTypedWrappers(appDir) {
     const outDir = (0, path_1.join)("apps", appDir, ".zite");
     (0, fs_2.mkdirSync)(outDir, { recursive: true });
@@ -66,7 +78,7 @@ function regenerateAppTypedWrappers(appDir) {
         (0, fs_2.mkdirSync)(intDir, { recursive: true });
         (0, fs_2.writeFileSync)((0, path_1.join)(intDir, "email.ts"), (0, lib_js_1.generateEmailSdk)(emailIntegrationId));
     }
-    (0, fs_2.writeFileSync)((0, path_1.join)(outDir, "backend.ts"), (0, lib_js_1.generateBackendWrapperTs)());
+    (0, fs_2.writeFileSync)((0, path_1.join)(outDir, "backend.ts"), (0, lib_js_1.generateBackendWrapperTs)(getDeclaredEnvVarNames(appDir)));
 }
 function regenerateAppApiTs(appDir) {
     const apiDir = (0, path_1.join)("apps", appDir, "src", "api");

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

@@ -21,7 +21,7 @@ export declare function toCamelCase(name: string): string;
  *
  * If `existingSchema` is provided, locked SDK names are preserved for
  * tables/fields that already exist (matched by ID). New tables/fields
- * get fresh camelCase SDK names. This is how `zitejs sync` preserves
+ * get fresh camelCase SDK names. This is how `zitejs generate` preserves
  * name stability across schema changes.
  */
 export declare function generateSchema(database: Database, existingSchema?: ZiteSchema): ZiteSchema;
@@ -58,7 +58,7 @@ export type AirtableLock = {
     tables: AirtableLockTable[];
 };
 export declare function generateAirtableTs(lock: AirtableLock): string | null;
-export declare function generateBackendWrapperTs(): string;
+export declare function generateBackendWrapperTs(envVarNames?: string[]): string;
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with
  * an email integration connected. Mirrors the airtable SDK generation: a thin

package/dist/cjs/sync/lib.js

@@ -188,7 +188,7 @@ function fieldJsdoc(schemaField, table) {
  *
  * If `existingSchema` is provided, locked SDK names are preserved for
  * tables/fields that already exist (matched by ID). New tables/fields
- * get fresh camelCase SDK names. This is how `zitejs sync` preserves
+ * get fresh camelCase SDK names. This is how `zitejs generate` preserves
  * name stability across schema changes.
  */
 function generateSchema(database, existingSchema) {
@@ -417,7 +417,7 @@ function generateApiTs(endpointFiles) {
     }
     const hasStreaming = endpoints.some((e) => e.stream);
     const lines = [
-        "// Auto-generated by zitejs sync. Do not edit manually.",
+        "// Auto-generated by zitejs generate. Do not edit manually.",
         "",
         hasStreaming
             ? "import { createCaller, createStreamingCaller } from 'zitejs/caller';"
@@ -460,7 +460,7 @@ function tsTypeForField(field) {
 }
 function generateUserTs(usersTableFields) {
     const lines = [
-        "// Auto-generated by zitejs sync. Do not edit manually.",
+        "// Auto-generated by zitejs generate. Do not edit manually.",
         "",
     ];
     if (usersTableFields && usersTableFields.length > 0) {
@@ -700,14 +700,20 @@ function generateAirtableTs(lock) {
     }
     return lines.join("\n");
 }
-function generateBackendWrapperTs() {
+function generateBackendWrapperTs(envVarNames = []) {
+    const names = [
+        "ZITE_APP_URL",
+        ...envVarNames.filter((n) => n !== "ZITE_APP_URL"),
+    ];
     return [
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",
         "// Re-exports createEndpoint with context.user typed to the app User.",
         "",
-        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext as _ZiteScheduledContext } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext as _ZiteScheduledContext, ZiteSchedule, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from './user';",
         "",
+        "export type { ZiteSchedule, ZiteWebhook };",
+        "",
         "export class ZiteError extends Error {",
         "  statusCode: number;",
         "  constructor(message: string, options?: { statusCode?: number }) {",
@@ -734,6 +740,8 @@ function generateBackendWrapperTs() {
         "  outputSchema?: SchemaLike<TOutput>;",
         "  stream?: boolean;",
         "  authenticated?: boolean;",
+        "  schedule?: ZiteSchedule;",
+        "  webhook?: ZiteWebhook;",
         "  execute: (params: { input: TInput; context: ZiteRequestContext | ZiteScheduledContext }) => Promise<TOutput> | TOutput;",
         "}",
         "",
@@ -743,6 +751,17 @@ function generateBackendWrapperTs() {
         "  return config;",
         "}",
         "",
+        // Declared in the wrapper (not a standalone .d.ts) so the merge is
+        // guaranteed to be in the program — every endpoint imports this file,
+        // while tsconfig `include` does not reliably pick up dot-directories.
+        "declare global {",
+        "  namespace NodeJS {",
+        "    interface ProcessEnv {",
+        ...names.map((name) => `      ${JSON.stringify(name)}: string;`),
+        "    }",
+        "  }",
+        "}",
+        "",
     ].join("\n");
 }
 /**