zitejs 0.9.74 → 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/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/db/index.js

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

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) {

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

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

package/dist/esm/api/index.js

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