zitejs 0.9.120 → 0.9.122

package/dist/esm/bundle/index.js

@@ -8,7 +8,7 @@
  *
  * Usage:
  *   npx zitejs bundle                     # bundle all endpoints
- *   npx zitejs bundle --app admin-panel   # bundle endpoints for a specific app
+ *   npx zitejs bundle --app admin-panel   # bundle endpoints for one app or automation, by dir name
  *   npx zitejs bundle --script <path>     # bundle a one-off script
  *
  * Output: JSON to stdout
@@ -24,6 +24,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { parse } from '@babel/parser';
 import { builtinModules } from 'node:module';
+import { findSourceDir } from '../sourceRoots.js';
 // workerd's `nodejs_compat` does not provide these. Left external they bundle
 // fine and then kill the worker at load time with `No such module`; excluded,
 // esbuild fails the one endpoint with a resolvable error instead. Pinned by
@@ -578,7 +579,10 @@ export async function runBundle() {
     const appFlag = args.indexOf('--app');
     let baseDir = process.cwd();
     if (appFlag !== -1 && args[appFlag + 1]) {
-        baseDir = path.resolve(baseDir, 'apps', args[appFlag + 1]);
+        const name = args[appFlag + 1];
+        // A dir that exists under no root still resolves under `apps/`, so the
+        // error names the path a caller expects rather than "not found".
+        baseDir = path.resolve(baseDir, findSourceDir(name, baseDir)?.path ?? path.join('apps', name));
     }
     // If explicit endpoint names passed, use those; otherwise find all.
     // Skipping `--app`'s VALUE as well as the flag: it is a positional arg, so

package/dist/esm/check/index.js

@@ -1,14 +1,7 @@
 import { execFileSync } from 'child_process';
-import { existsSync, readdirSync } from 'fs';
+import { existsSync } from 'fs';
 import { join } from 'path';
-function findAppDirs() {
-    const appsDir = 'apps';
-    if (!existsSync(appsDir))
-        return [];
-    return readdirSync(appsDir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name);
-}
+import { listSourceDirs } from '../sourceRoots.js';
 /**
  * An argument array, not a command string, so no shell is involved.
  *
@@ -63,15 +56,14 @@ function bundleFailures(output) {
     return failures;
 }
 export async function runCheck() {
-    const appDirs = findAppDirs();
+    const appDirs = listSourceDirs();
     if (appDirs.length === 0) {
-        console.error('No apps found in apps/ directory.');
+        console.error('No apps or automations found under apps/ or automations/.');
         process.exit(1);
     }
     let allPassed = true;
-    for (const app of appDirs) {
-        const appPath = join('apps', app);
-        console.log(`\n── ${app} ──`);
+    for (const { dir: app, path: appPath } of appDirs) {
+        console.log(`\n── ${appPath} ──`);
         // 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

package/dist/esm/cli.js

@@ -38,8 +38,8 @@ async function main() {
             console.error('Commands:');
             console.error('  sync      Generate .zite/db.ts from database schema (single-app)');
             console.error('  dev       Run sync then watch for changes (like npx convex dev)');
-            console.error('  generate  One-shot sync + regenerate all apps .zite/ files (monorepo)');
-            console.error('  check   Run tsc --noEmit and vite build for all apps');
+            console.error('  generate  Regenerate every app and automation .zite/ (monorepo)');
+            console.error('  check   Run tsc --noEmit (and vite build where there is one) for every app and automation');
             console.error('  bundle  Bundle src/api/*.ts endpoints for cloudflare-lambda');
             process.exit(1);
     }

package/dist/esm/dev/index.js

@@ -1,6 +1,7 @@
 import { watch } from "fs";
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, } from "fs";
 import { join } from "path";
+import { listSourceDirs } from "../sourceRoots.js";
 import { runSync } from "../sync/index.js";
 import { generateDbTs, generateApiTs, generateBackendWrapperTs, generateAirtableTs, findEmailIntegrationId, generateEmailSdk, } from "../sync/lib.js";
 const debounceTimers = new Map();
@@ -10,17 +11,9 @@ function debounce(key, fn, ms) {
         clearTimeout(existing);
     debounceTimers.set(key, setTimeout(fn, ms));
 }
-function findAppDirs() {
-    const appsDir = "apps";
-    if (!existsSync(appsDir))
-        return [];
-    return readdirSync(appsDir, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .map((d) => d.name);
-}
 function getFlowId(appDir) {
     try {
-        const configPath = join("apps", appDir, "zite.config.json");
+        const configPath = join(appDir.path, "zite.config.json");
         if (existsSync(configPath)) {
             const config = JSON.parse(readFileSync(configPath, "utf-8"));
             return config.id;
@@ -40,11 +33,11 @@ const readJsonFile = (path) => {
     }
 };
 function getEmailIntegrationId(appDir) {
-    return findEmailIntegrationId(readJsonFile(join("apps", appDir, "zite.config.json")), readJsonFile("zite.config.json"));
+    return findEmailIntegrationId(readJsonFile(join(appDir.path, "zite.config.json")), readJsonFile("zite.config.json"));
 }
 function getDeclaredEnvVarNames(appDir) {
     try {
-        const configPath = join("apps", appDir, "zite.config.json");
+        const configPath = join(appDir.path, "zite.config.json");
         if (!existsSync(configPath))
             return [];
         const config = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -55,7 +48,7 @@ function getDeclaredEnvVarNames(appDir) {
     }
 }
 function regenerateAppTypedWrappers(appDir) {
-    const outDir = join("apps", appDir, ".zite");
+    const outDir = join(appDir.path, ".zite");
     mkdirSync(outDir, { recursive: true });
     // user.ts and auth.ts no longer generated — User type is fixed in zitejs/auth
     // Email integration: generate the Email client at .zite/integrations/email.ts.
@@ -70,7 +63,7 @@ function regenerateAppTypedWrappers(appDir) {
     writeFileSync(join(outDir, "backend.ts"), generateBackendWrapperTs(getDeclaredEnvVarNames(appDir)));
 }
 function regenerateAppApiTs(appDir) {
-    const apiDir = join("apps", appDir, "src", "api");
+    const apiDir = join(appDir.path, "src", "api");
     if (!existsSync(apiDir))
         return;
     // Sorted because `readdir` order is unspecified — it is whatever the
@@ -90,14 +83,14 @@ function regenerateAppApiTs(appDir) {
     }));
     const content = generateApiTs(endpointFiles);
     if (content) {
-        const outDir = join("apps", appDir, ".zite");
+        const outDir = join(appDir.path, ".zite");
         mkdirSync(outDir, { recursive: true });
         writeFileSync(join(outDir, "api.ts"), content);
-        console.log(`Updated apps/${appDir}/.zite/api.ts`);
+        console.log(`Updated ${appDir.path}/.zite/api.ts`);
     }
 }
 function regenerateAppAirtableSdk(appDir) {
-    const lockPath = join("apps", appDir, "zite.lock");
+    const lockPath = join(appDir.path, "zite.lock");
     console.log(`[airtable-sdk] Checking ${lockPath} exists: ${existsSync(lockPath)}`);
     if (!existsSync(lockPath))
         return;
@@ -118,15 +111,15 @@ function regenerateAppAirtableSdk(appDir) {
             };
             const content = generateAirtableTs(airtableLock);
             if (content) {
-                const outDir = join("apps", appDir, ".zite", "integrations");
+                const outDir = join(appDir.path, ".zite", "integrations");
                 mkdirSync(outDir, { recursive: true });
                 writeFileSync(join(outDir, "airtable.ts"), content);
-                console.log(`Updated apps/${appDir}/.zite/integrations/airtable.ts`);
+                console.log(`Updated ${appDir.path}/.zite/integrations/airtable.ts`);
             }
         }
     }
     catch (err) {
-        console.error(`[airtable-sdk] Error processing lock for ${appDir}:`, err);
+        console.error(`[airtable-sdk] Error processing lock for ${appDir.path}:`, err);
     }
 }
 export async function runGenerate() {
@@ -150,8 +143,8 @@ export async function runGenerate() {
     catch (err) {
         console.warn("DB SDK generation failed:", err instanceof Error ? err.message : err);
     }
-    // 2. Find all apps and regenerate their .zite/ files
-    const appDirs = findAppDirs();
+    // 2. Find every app and automation and regenerate their .zite/ files
+    const appDirs = listSourceDirs();
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
@@ -171,33 +164,33 @@ export async function runDev() {
         console.warn("Initial sync failed (continuing with watcher):", err instanceof Error ? err.message : err);
     }
     console.log("");
-    // 2. Find all apps and regenerate their .zite/ files
-    const appDirs = findAppDirs();
+    // 2. Find every app and automation and regenerate their .zite/ files
+    const appDirs = listSourceDirs();
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
     }
-    // 3. Watch each app's src/api/ for endpoint changes
+    // 3. Watch each dir's src/api/ for endpoint changes
     let watchingAny = false;
     for (const app of appDirs) {
-        const apiDir = join("apps", app, "src", "api");
+        const apiDir = join(app.path, "src", "api");
         if (!existsSync(apiDir))
             continue;
         watchingAny = true;
-        console.log(`Watching apps/${app}/src/api/ for endpoint changes...`);
+        console.log(`Watching ${app.path}/src/api/ for endpoint changes...`);
         watch(apiDir, { recursive: true }, (_event, filename) => {
             if (!filename)
                 return;
             if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
                 return;
-            debounce(app, () => {
-                console.log(`Endpoint changed in ${app}: ${filename}`);
+            debounce(app.path, () => {
+                console.log(`Endpoint changed in ${app.path}: ${filename}`);
                 regenerateAppApiTs(app);
             }, 200);
         });
     }
     if (!watchingAny) {
-        console.log("No apps with src/api/ found.");
+        console.log("No apps or automations with src/api/ found.");
     }
     // 4. Watch zite.schema.json for schema drift
     if (existsSync("zite.schema.json")) {

package/dist/esm/sourceRoots.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The repo-root directories a project's own source lives under: `apps/` for
+ * apps and `automations/` for automations (endpoints with no frontend). The
+ * backend keeps the same list; a dir name is unique across both roots, so a
+ * bare name still identifies one dir.
+ */
+export declare const SOURCE_ROOTS: readonly ["apps", "automations"];
+export type SourceRoot = (typeof SOURCE_ROOTS)[number];
+export interface SourceDir {
+    root: SourceRoot;
+    /** The bare directory name. */
+    dir: string;
+    /** `<root>/<dir>`, relative to the repo root. */
+    path: string;
+}
+/** Every source dir under every root, in root order then name order. */
+export declare function listSourceDirs(cwd?: string): SourceDir[];
+/** The source dir with this bare name, under whichever root holds it. */
+export declare function findSourceDir(name: string, cwd?: string): SourceDir | undefined;

package/dist/esm/sourceRoots.js

@@ -0,0 +1,28 @@
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+/**
+ * The repo-root directories a project's own source lives under: `apps/` for
+ * apps and `automations/` for automations (endpoints with no frontend). The
+ * backend keeps the same list; a dir name is unique across both roots, so a
+ * bare name still identifies one dir.
+ */
+export const SOURCE_ROOTS = ["apps", "automations"];
+/** Every source dir under every root, in root order then name order. */
+export function listSourceDirs(cwd = ".") {
+    const dirs = [];
+    for (const root of SOURCE_ROOTS) {
+        const rootPath = join(cwd, root);
+        if (!existsSync(rootPath))
+            continue;
+        for (const entry of readdirSync(rootPath, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            dirs.push({ root, dir: entry.name, path: join(root, entry.name) });
+        }
+    }
+    return dirs;
+}
+/** The source dir with this bare name, under whichever root holds it. */
+export function findSourceDir(name, cwd = ".") {
+    return listSourceDirs(cwd).find((d) => d.dir === name);
+}

package/dist/esm/sync/lib.js

@@ -1216,10 +1216,10 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "// 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, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
-        "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteWebhook };",
+        "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // The pre-monorepo SDK put this in scope for every endpoint, so migrated
         // code can name it. `createEndpoint` infers the same thing without it.
         "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
@@ -1294,7 +1294,7 @@ export function generateBackendWrapperTs(envVarNames = []) {
         // TStream mirrors zitejs/backend/base. Without it `stream: true` endpoints
         // get no `stream` argument here — and this wrapper, not the base module, is
         // what `zitejs/backend` resolves to in every app.
-        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {",
+        "export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput, TTrigger extends ZiteTrigger | undefined = undefined> {",
         "  description?: string;",
         "  inputSchema?: SchemaLike<TInput, TRawInput>;",
         // Apps compile against this copy, not the base module's.
@@ -1306,17 +1306,19 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  schedule?: TSchedule;",
         "  /** When set, an inbound webhook can also trigger this endpoint. Like `schedule`, it widens `context` — a webhook fire has no session. */",
         "  webhook?: TWebhook;",
+        "  /** When set, a workspace connection's events (registered by `src/triggers/<endpointId>/subscribe.ts`) or a poll also fire this endpoint. Like `webhook`, it widens `context` — a trigger fire has no session. */",
+        "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
         "      input: TInput;",
-        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
+        "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
         "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",
-        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(",
-        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>,",
-        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput> {",
+        "export function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput, TTrigger extends ZiteTrigger | undefined = undefined>(",
+        "  config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput, TTrigger>,",
+        "): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput, TTrigger> {",
         "  return config;",
         "}",
         "",

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

@@ -376,6 +376,11 @@ describe('generateBackendWrapperTs', () => {
     it('exports createEndpoint', () => {
         expect(output).toContain('createEndpoint');
     });
+    it('types the trigger field like schedule and webhook', () => {
+        expect(output).toContain('trigger?: TTrigger;');
+        expect(output).toContain('TTrigger extends ZiteTrigger | undefined = undefined');
+        expect(output).toContain('ZiteTrigger, ZiteWebhook }');
+    });
     it('exports ZiteError', () => {
         expect(output).toContain('ZiteError');
     });

package/dist/esm/upload/index.js

@@ -106,6 +106,25 @@ async function performUpload(data, filename) {
     if (!putRes.ok) {
         throw new FileUploadError('Upload failed');
     }
+    // Gateways that predate the storage ledger omit the token. The file is
+    // already at fileUrl, so those uploads still succeed.
+    if (session.completionToken) {
+        const completeRes = await fetch(getApiUrl() +
+            '/v1/zite/public/' +
+            flowId +
+            '/complete-upload?mode=' +
+            mode, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...authHeaders(),
+            },
+            body: JSON.stringify({ completionToken: session.completionToken }),
+        });
+        if (!completeRes.ok) {
+            throw new FileUploadError(await readErrorMessage(completeRes, 'Upload failed'));
+        }
+    }
     return session.fileUrl;
 }
 export async function uploadFile({ data, filename, }) {

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

@@ -23,7 +23,7 @@ describe('toUploadBlob', () => {
     });
 });
 describe('uploadFile', () => {
-    it('requests a session then PUTs the bytes to the presigned URL', async () => {
+    it('requests a session, PUTs the bytes, then completes the upload', async () => {
         const file = new File(['hello-world'], 'hello.txt', { type: 'text/plain' });
         fetchMock
             .mockResolvedValueOnce({
@@ -33,12 +33,14 @@ describe('uploadFile', () => {
                 presignedUrl: 'https://s3.example.com/put',
                 fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
                 contentType: 'text/plain',
+                completionToken: 'signed-token',
             }),
         })
-            .mockResolvedValueOnce({ ok: true });
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ ok: true, json: async () => ({ success: true }) });
         const result = await uploadFile({ data: file, filename: 'hello.txt' });
         expect(result.fileUrl).toContain('hello.txt');
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
         expect(fetchMock.mock.calls[0][0]).toBe('https://api.example.com/v1/zite/public/app_123/upload-session?mode=live');
         const sessionInit = fetchMock.mock.calls[0][1];
         expect(JSON.parse(sessionInit.body)).toEqual({
@@ -48,6 +50,31 @@ describe('uploadFile', () => {
         });
         expect(fetchMock.mock.calls[1][0]).toBe('https://s3.example.com/put');
         expect(fetchMock.mock.calls[1][1].method).toBe('PUT');
+        expect(fetchMock.mock.calls[2][0]).toBe('https://api.example.com/v1/zite/public/app_123/complete-upload?mode=live');
+        const completeInit = fetchMock.mock.calls[2][1];
+        expect(completeInit.method).toBe('POST');
+        expect(JSON.parse(completeInit.body)).toEqual({
+            completionToken: 'signed-token',
+        });
+    });
+    it('skips completion when the gateway does not issue a token', async () => {
+        fetchMock
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                presignedUrl: 'https://s3.example.com/put',
+                fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
+                contentType: 'text/plain',
+            }),
+        })
+            .mockResolvedValueOnce({ ok: true });
+        const result = await uploadFile({
+            data: new File(['hello-world'], 'hello.txt', { type: 'text/plain' }),
+            filename: 'hello.txt',
+        });
+        expect(result.fileUrl).toContain('hello.txt');
+        expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     it('surfaces the plan-limit message from the session endpoint', async () => {
         fetchMock.mockResolvedValueOnce({

package/dist/esm/vite/domTagNames.d.ts

@@ -0,0 +1 @@
+export declare const domTagNames: ReadonlySet<string>;