zitejs 0.9.74 → 0.9.76

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

@@ -0,0 +1,265 @@
+export interface ZiteAuthUser {
+    id: string;
+    email: string;
+    name: string;
+    firstName?: string;
+    lastName?: string;
+}
+export interface ZiteAuthMethods {
+    emailPassword?: boolean;
+    magicLink?: boolean;
+    googleSignIn?: boolean;
+    sso?: boolean;
+}
+export interface ZiteAuthSettings {
+    methods?: ZiteAuthMethods;
+    signup?: 'disabled' | 'open' | 'domain-restricted';
+    domains?: string[];
+}
+export interface ZiteAuthConfig {
+    flowPublicId?: string;
+    authSettings?: ZiteAuthSettings;
+    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: boolean;
+    };
+    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">;
+        };
+    }[];
+    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;
+            };
+        };
+        session: {
+            create: {
+                after: ((session: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    userId: string;
+                    expiresAt: Date;
+                    token: string;
+                    ipAddress?: string | null | undefined;
+                    userAgent?: string | null | undefined;
+                } & Record<string, unknown>) => Promise<void>) | undefined;
+            };
+        };
+    };
+}>;

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

@@ -0,0 +1,113 @@
+"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 methods = config.authSettings?.methods ?? {};
+    const signup = config.authSettings?.signup ?? 'open';
+    const allowedDomains = config.authSettings?.domains ?? [];
+    const 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',
+                },
+                ...(methods.googleSignIn !== false
+                    ? [
+                        {
+                            providerId: 'google',
+                            clientId: process.env.ZITE_GOOGLE_PROXY_CLIENT_ID,
+                            clientSecret: process.env.ZITE_GOOGLE_PROXY_CLIENT_SECRET,
+                            authorizationUrl: process.env.ZITE_AUTH_URL + '/proxy/google/authorize',
+                            tokenUrl: process.env.ZITE_AUTH_URL + '/proxy/google/token',
+                        },
+                    ]
+                    : []),
+            ],
+        }),
+    ];
+    if (methods.magicLink !== false) {
+        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}`);
+            };
+        plugins.push((0, plugins_1.magicLink)({ sendMagicLink: sendMagicLinkEmail }));
+    }
+    const domainCheckHook = signup === 'domain-restricted' && allowedDomains.length > 0
+        ? async (email) => {
+            const domain = email.split('@')[1]?.toLowerCase();
+            if (!domain || !allowedDomains.some(d => d.toLowerCase() === domain)) {
+                return false;
+            }
+            return config.beforeSignup ? config.beforeSignup(email) : true;
+        }
+        : signup === 'disabled'
+            ? async (_email) => false
+            : config.beforeSignup;
+    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: methods.emailPassword !== false },
+        plugins,
+        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: domainCheckHook
+                        ? async (user) => {
+                            const allowed = await domainCheckHook(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,
+                },
+            },
+            session: {
+                create: {
+                    after: config.onLogin
+                        ? async (session) => {
+                            await config.onLogin({
+                                id: session.userId,
+                                email: '',
+                                name: '',
+                            });
+                        }
+                        : 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) {
@@ -492,17 +492,11 @@ function generateUserTs(usersTableFields) {
 }
 function generateAuthWrapperTs() {
     return [
-        "// Auto-generated type-narrowing wrapper. Do not edit manually.",
+        "// Auto-generated auth re-exports. Do not edit manually.",
         "// The real auth logic lives in the zitejs npm package (zitejs/auth).",
         "",
-        "import { useAuth as _useAuth } from 'zitejs/auth/base';",
-        "import type { User } from './user';",
-        "",
-        "export type { User };",
-        "",
-        "export function useAuth() {",
-        "  return _useAuth() as ReturnType<typeof _useAuth> & { user: User | undefined };",
-        "}",
+        "export { useSession, signIn, signOut, signUp, loginWithRedirect, logout } from 'zitejs/auth';",
+        "export type { User } from 'zitejs/auth';",
         "",
     ].join("\n");
 }

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';