zitejs 0.9.122 → 0.9.124

package/dist/esm/bundle/index.js

@@ -2,7 +2,7 @@
  * `npx zitejs bundle` — Bundle endpoint files for cloudflare-lambda deployment.
  *
  * Replaces the legacy `scripts/bundle-endpoints.js` from zitejs-starter.
- * Reads endpoints from src/api/*.ts, resolves SDK imports via .zite/backend.ts
+ * Reads an app's src/api/*.ts endpoints (an automation's single src/workflow.ts), resolves SDK imports via .zite/backend.ts
  * (monorepo) or src/__zite__/integrations.ts (legacy), and outputs bundled ESM
  * code suitable for the cloudflare-lambda worker runtime.
  *
@@ -24,7 +24,9 @@ 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';
+import { INTEGRATIONS_CLASS_NAME, INTEGRATIONS_SDK_INTEGRATION_ID, } from '../integrations/client.js';
+import { SDK_NOT_INITIALIZED_MESSAGE } from '../internal/sdkCall.js';
+import { AUTOMATION_ENDPOINT_NAME, endpointEntryFile, findSourceDir, listEndpointNames, sourceRootOf, } 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
@@ -192,7 +194,7 @@ function getSdkImportSource(baseDir) {
     return 'zite-integrations-backend-sdk';
 }
 /**
- * `zitejs/db`, `zitejs/api`, `zitejs/integrations` and `zitejs/email` are
+ * `zitejs/db`, `zitejs/api` and `zitejs/email` are
  * tsconfig aliases onto generated files, not real package subpaths — they are
  * absent from the `exports` map. `zitejs/backend` IS a real subpath export, but
  * it lands here too and `zitejs` is not in PREBUNDLED_LIBS, so nothing would
@@ -205,7 +207,19 @@ const unresolvedAlias = (specifier, expectedPath) => {
     throw new Error(`Cannot resolve '${specifier}': expected generated file at ${expectedPath}. ` +
         `Run \`npx zitejs generate\` before bundling.`);
 };
-function createAliasPlugin(opts) {
+const AUTH_SERVER_SHIM_PATH = 'zitejs-auth-server-shim';
+const INTEGRATIONS_SHIM_PATH = 'zitejs-integrations-shim';
+const VIRTUAL_MODULES = {
+    [AUTH_SERVER_SHIM_PATH]: 'export const ziteAuth = (config) => config;',
+    [INTEGRATIONS_SHIM_PATH]: `export const integrations = {
+  get(name) {
+    const sdkCall = globalThis.__wrapSdkCall;
+    if (!sdkCall) throw new Error(${JSON.stringify(SDK_NOT_INITIALIZED_MESSAGE)});
+    return sdkCall(${JSON.stringify(INTEGRATIONS_SDK_INTEGRATION_ID)}, ${JSON.stringify(INTEGRATIONS_CLASS_NAME)}, 'get', { name });
+  },
+};`,
+};
+export function createAliasPlugin(opts) {
     return {
         name: 'zite-alias',
         setup(build) {
@@ -256,14 +270,18 @@ function createAliasPlugin(opts) {
                 }
                 return unresolvedAlias('zitejs/api', `${opts.baseDir}/.zite/api.ts`);
             });
-            // Resolve zitejs/integrations to .zite/integrations/airtable.ts
+            // zitejs/integrations: the generated index (the integrations client plus
+            // any Airtable clients), else Airtable alone from an older generate, else
+            // this bundler's own client, whatever zitejs the project pins.
             build.onResolve({ filter: /^zitejs\/integrations$/ }, () => {
                 if (opts.baseDir) {
-                    const intPath = path.resolve(opts.baseDir, '.zite/integrations/airtable.ts');
-                    if (fs.existsSync(intPath))
-                        return { path: intPath };
+                    for (const file of ['index.ts', 'airtable.ts']) {
+                        const intPath = path.resolve(opts.baseDir, '.zite/integrations', file);
+                        if (fs.existsSync(intPath))
+                            return { path: intPath };
+                    }
                 }
-                return unresolvedAlias('zitejs/integrations', `${opts.baseDir}/.zite/integrations/airtable.ts`);
+                return { path: INTEGRATIONS_SHIM_PATH, namespace: 'zite-virtual' };
             });
             // Resolve zitejs/email to .zite/integrations/email.ts
             build.onResolve({ filter: /^zitejs\/email$/ }, () => {
@@ -277,11 +295,11 @@ function createAliasPlugin(opts) {
             // zitejs/auth/server is types + an identity wrapper — inline a shim so
             // zite.auth.ts bundles without resolving the installed package.
             build.onResolve({ filter: /^zitejs\/auth\/server$/ }, () => ({
-                path: 'zitejs-auth-server-shim',
+                path: AUTH_SERVER_SHIM_PATH,
                 namespace: 'zite-virtual',
             }));
-            build.onLoad({ filter: /.*/, namespace: 'zite-virtual' }, () => ({
-                contents: 'export const ziteAuth = (config) => config;',
+            build.onLoad({ filter: /.*/, namespace: 'zite-virtual' }, (args) => ({
+                contents: VIRTUAL_MODULES[args.path],
                 loader: 'js',
             }));
             // zitejs/runtime is NOT in PREBUNDLED_LIBS — it's a thin fetch()
@@ -297,7 +315,7 @@ function createAliasPlugin(opts) {
         },
     };
 }
-function generateEndpointWrapper(endpointName, usedImports, sdkExportKinds, sdkSource) {
+function generateEndpointWrapper(entryImport, usedImports, sdkExportKinds, sdkSource) {
     // Always import the prebundled runtime to ensure globalThis.__wrapSdkCall
     // is available for createTableClient/createSqlClient from zitejs/runtime.
     const runtimeInit = `import { __wrapSdkCall, initRuntime } from '@zite/endpoints-runtime-sdk';
@@ -308,14 +326,14 @@ initRuntime();`;
 ${runtimeInit}
 import * as sdk from '${sdkSource}';
 Object.assign(globalThis, sdk);
-import endpoint from './api/${endpointName}';
+import endpoint from '${entryImport}';
 globalThis.__endpoint = endpoint;
 `;
     }
     if (usedImports.length === 0) {
         return `
 ${runtimeInit}
-import endpoint from './api/${endpointName}';
+import endpoint from '${entryImport}';
 globalThis.__endpoint = endpoint;
 `;
     }
@@ -343,11 +361,11 @@ globalThis.__endpoint = endpoint;
 ${runtimeInit}
 ${importStatements.join('\n')}
 ${globalAssign}
-import endpoint from './api/${endpointName}';
+import endpoint from '${entryImport}';
 globalThis.__endpoint = endpoint;
 `;
 }
-async function bundleEndpointsImpl(baseDir, endpointNames) {
+async function bundleEndpointsImpl(baseDir, root, endpointNames) {
     const bundledEndpoints = {};
     const endpointErrors = {};
     const aliasPlugin = createAliasPlugin({ baseDir });
@@ -362,14 +380,20 @@ async function bundleEndpointsImpl(baseDir, endpointNames) {
     }
     catch { }
     for (const name of endpointNames) {
+        if (root === 'automations' && name !== AUTOMATION_ENDPOINT_NAME) {
+            endpointErrors[name] =
+                `An automation is one workflow, src/workflow.ts, bundled as "${AUTOMATION_ENDPOINT_NAME}"; there is no endpoint "${name}"`;
+            continue;
+        }
+        const entryFile = endpointEntryFile(root, name);
         let usedImports = null;
         try {
-            const endpointPath = path.join(baseDir, 'src', 'api', `${name}.ts`);
-            const endpointCode = fs.readFileSync(endpointPath, 'utf-8');
+            const endpointCode = fs.readFileSync(path.join(baseDir, entryFile), 'utf-8');
             usedImports = getUsedSdkImports(endpointCode);
         }
         catch { }
-        const wrapperCode = generateEndpointWrapper(name, usedImports, sdkExportKinds, sdkSource);
+        // The wrapper resolves from `src/`, so the entry is imported relative to it.
+        const wrapperCode = generateEndpointWrapper('./' + path.relative('src', entryFile).replace(/\.ts$/, ''), usedImports, sdkExportKinds, sdkSource);
         try {
             const result = await esbuild.build({
                 ...BASE_BUILD_OPTIONS,
@@ -592,18 +616,13 @@ export async function runBundle() {
     // as missing.
     const explicitNames = args.filter((a, i) => !a.startsWith('--') && !(appFlag !== -1 && i === appFlag + 1));
     let endpointNames;
+    const root = sourceRootOf(baseDir) ?? 'apps';
     if (explicitNames.length > 0) {
         endpointNames = explicitNames;
     }
     else {
-        const apiDir = path.join(baseDir, 'src', 'api');
-        endpointNames = fs.existsSync(apiDir)
-            ? fs
-                .readdirSync(apiDir)
-                .filter(f => f.endsWith('.ts'))
-                .map(f => f.replace('.ts', ''))
-            : [];
+        endpointNames = listEndpointNames(root, baseDir);
     }
     // Even with no endpoints, zite.auth.ts may still need bundling.
-    return bundleEndpointsImpl(baseDir, endpointNames);
+    return bundleEndpointsImpl(baseDir, root, endpointNames);
 }

package/dist/esm/check/index.js

@@ -1,7 +1,7 @@
 import { execFileSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { listSourceDirs } from '../sourceRoots.js';
+import { listEndpointNames, listSourceDirs } from '../sourceRoots.js';
 /**
  * An argument array, not a command string, so no shell is involved.
  *
@@ -62,7 +62,7 @@ export async function runCheck() {
         process.exit(1);
     }
     let allPassed = true;
-    for (const { dir: app, path: appPath } of appDirs) {
+    for (const { root, 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
@@ -89,7 +89,7 @@ export async function runCheck() {
         // Endpoints never reach vite — they are bundled separately for the lambda,
         // against a different resolver. tsc and vite both pass on an endpoint whose
         // `zitejs/*` alias has no generated file behind it; only the bundler knows.
-        if (existsSync(join(appPath, 'src', 'api'))) {
+        if (listEndpointNames(root, appPath).length > 0) {
             process.stdout.write('  bundle endpoints ... ');
             const bundle = run('npx', ['zitejs', 'bundle', '--app', app], '.');
             const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];

package/dist/esm/cli.js

@@ -40,7 +40,7 @@ async function main() {
             console.error('  dev       Run sync then watch for changes (like npx convex dev)');
             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');
+            console.error('  bundle  Bundle endpoints (src/api/*.ts, or an automation\'s src/workflow.ts) for cloudflare-lambda');
             process.exit(1);
     }
 }

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

@@ -1,2 +1,7 @@
+/**
+ * Whether the zitejs that `fromDir` resolves, nearest first up to the project root,
+ * has the integrations client: the CLI running generate can be newer than that pin.
+ */
+export declare function projectRuntimeHasIntegrationsClient(fromDir: string, projectRoot?: string): boolean;
 export declare function runGenerate(): Promise<void>;
 export declare function runDev(): Promise<void>;

package/dist/esm/dev/index.js

@@ -1,9 +1,10 @@
 import { watch } from "fs";
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, } from "fs";
-import { join } from "path";
+import { dirname, join, resolve } from "path";
 import { listSourceDirs } from "../sourceRoots.js";
 import { runSync } from "../sync/index.js";
-import { generateDbTs, generateApiTs, generateBackendWrapperTs, generateAirtableTs, findEmailIntegrationId, generateEmailSdk, } from "../sync/lib.js";
+import { generateDbTs, generateApiTs, generateBackendWrapperTs, generateAirtableTs, findEmailIntegrationId, generateEmailSdk, generateIntegrationsIndex, } from "../sync/lib.js";
+import { gettableIntegrations, } from "../integrations/rules.js";
 const debounceTimers = new Map();
 function debounce(key, fn, ms) {
     const existing = debounceTimers.get(key);
@@ -35,6 +36,48 @@ const readJsonFile = (path) => {
 function getEmailIntegrationId(appDir) {
     return findEmailIntegrationId(readJsonFile(join(appDir.path, "zite.config.json")), readJsonFile("zite.config.json"));
 }
+// `{}` with no file; undefined when unreadable, so a failed read keeps the old file.
+const readConfigIntegrations = (path) => {
+    if (!existsSync(path))
+        return {};
+    const config = readJsonFile(path);
+    if (typeof config !== "object" || config === null)
+        return undefined;
+    const { integrations } = config;
+    if (integrations == null)
+        return {};
+    return typeof integrations === "object" && !Array.isArray(integrations)
+        ? integrations
+        : undefined;
+};
+/**
+ * Whether the zitejs that `fromDir` resolves, nearest first up to the project root,
+ * has the integrations client: the CLI running generate can be newer than that pin.
+ */
+export function projectRuntimeHasIntegrationsClient(fromDir, projectRoot = process.cwd()) {
+    const root = resolve(projectRoot);
+    for (let dir = resolve(fromDir);; dir = dirname(dir)) {
+        const pkg = readJsonFile(join(dir, "node_modules", "zitejs", "package.json"));
+        if (pkg)
+            return pkg.exports?.["./integrations"] !== undefined;
+        if (dir === root || dirname(dir) === dir)
+            return false;
+    }
+}
+// Runs after the Airtable step, so the index re-exports its clients when they exist.
+function regenerateAppIntegrationsIndex(appDir) {
+    if (!projectRuntimeHasIntegrationsClient(appDir.path))
+        return;
+    const root = readConfigIntegrations("zite.config.json");
+    const own = readConfigIntegrations(join(appDir.path, "zite.config.json"));
+    if (!root || !own)
+        return;
+    const intDir = join(appDir.path, ".zite", "integrations");
+    mkdirSync(intDir, { recursive: true });
+    writeFileSync(join(intDir, "index.ts"), generateIntegrationsIndex(gettableIntegrations(root, own), {
+        reexportAirtable: existsSync(join(intDir, "airtable.ts")),
+    }));
+}
 function getDeclaredEnvVarNames(appDir) {
     try {
         const configPath = join(appDir.path, "zite.config.json");
@@ -149,6 +192,7 @@ export async function runGenerate() {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
         regenerateAppAirtableSdk(app);
+        regenerateAppIntegrationsIndex(app);
     }
     console.log("Done!");
 }
@@ -169,6 +213,7 @@ export async function runDev() {
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
+        regenerateAppIntegrationsIndex(app);
     }
     // 3. Watch each dir's src/api/ for endpoint changes
     let watchingAny = false;
@@ -190,7 +235,7 @@ export async function runDev() {
         });
     }
     if (!watchingAny) {
-        console.log("No apps or automations with src/api/ found.");
+        console.log("No apps with src/api/ found.");
     }
     // 4. Watch zite.schema.json for schema drift
     if (existsSync("zite.schema.json")) {

package/dist/esm/index.d.ts

@@ -1,3 +1,5 @@
 export { Zite } from "./client/index.js";
 export type { Record, RecordListOutput, RecordListOptions, FieldCreateInput, FieldUpdateInput, TableCreateInput, TableUpdateInput, DatabaseCreateInput, DatabaseListOutput, } from "./client/index.js";
 export * from "./types/index.js";
+export { CREDENTIAL_FIELDS, NON_CREDENTIAL_SERVICE_TYPES, gettableIntegrations, isCredentialServiceType, normalizeIntegrationServiceType, } from "./integrations/rules.js";
+export type { ConfigIntegrations, CredentialServiceType, GettableIntegration, } from "./integrations/rules.js";

package/dist/esm/index.js

@@ -1,2 +1,3 @@
 export { Zite } from "./client/index.js";
 export * from "./types/index.js";
+export { CREDENTIAL_FIELDS, NON_CREDENTIAL_SERVICE_TYPES, gettableIntegrations, isCredentialServiceType, normalizeIntegrationServiceType, } from "./integrations/rules.js";

package/dist/esm/integrations/client.d.ts

@@ -0,0 +1,25 @@
+export declare const INTEGRATIONS_SDK_INTEGRATION_ID = "__connections__";
+export declare const INTEGRATIONS_CLASS_NAME = "Connections";
+/**
+ * `accessToken` is the service's primary credential (for Twilio the account SID).
+ * Call `get` where the value is used: a token refreshed mid-run is what the next call returns.
+ */
+export type Connected<Extra = {}> = {
+    status: "connected";
+    accessToken: string;
+} & Extra;
+/** No account behind the entry, or its token could not be refreshed. `connectUrl` is where a person fixes that. */
+export type NeedsConnect = {
+    status: "missing" | "expired";
+    connectUrl: string;
+};
+export interface IntegrationsClient<ByName extends Record<string, unknown>> {
+    /** The credentials of the `zite.config.json` integration entry named `name`. */
+    get<Name extends keyof ByName & string>(name: Name): Promise<ByName[Name]>;
+}
+/**
+ * `ByName` maps each entry name to its answer, e.g.
+ * `{ crm: Connected<{ instanceUrl: string }> | NeedsConnect }`; `zitejs generate`
+ * writes it per app into `.zite/integrations/index.ts`.
+ */
+export declare function createIntegrationsClient<ByName extends Record<string, unknown>>(): IntegrationsClient<ByName>;

package/dist/esm/integrations/client.js

@@ -0,0 +1,17 @@
+import { getSdkCall } from "../internal/sdkCall.js";
+// The worker and runner answer this call under its original name; renaming the
+// wire protocol would break every deployed bundle for no user-visible gain.
+export const INTEGRATIONS_SDK_INTEGRATION_ID = "__connections__";
+export const INTEGRATIONS_CLASS_NAME = "Connections";
+/**
+ * `ByName` maps each entry name to its answer, e.g.
+ * `{ crm: Connected<{ instanceUrl: string }> | NeedsConnect }`; `zitejs generate`
+ * writes it per app into `.zite/integrations/index.ts`.
+ */
+export function createIntegrationsClient() {
+    return {
+        get(name) {
+            return getSdkCall()(INTEGRATIONS_SDK_INTEGRATION_ID, INTEGRATIONS_CLASS_NAME, "get", { name });
+        },
+    };
+}

package/dist/esm/integrations/client.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/integrations/client.test-d.js

@@ -0,0 +1,48 @@
+import { describe, it, expectTypeOf } from "vitest";
+import { createIntegrationsClient, } from "./client.js";
+import { integrations as untyped } from "./index.js";
+import { CREDENTIAL_FIELDS, isCredentialServiceType } from "../index.js";
+describe("createIntegrationsClient", () => {
+    const client = createIntegrationsClient();
+    it("types each name's answer", () => {
+        expectTypeOf(client.get("crm")).resolves.toEqualTypeOf();
+    });
+    it("rejects a name the app cannot see", () => {
+        // @ts-expect-error not a visible entry
+        void client.get("nope");
+    });
+    // What `.zite/integrations/index.ts` emits when nothing is visible.
+    it("accepts an empty map, naming nothing", () => {
+        const none = createIntegrationsClient();
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("narrows to the connected fields on status", async () => {
+        const crm = await client.get("crm");
+        if (crm.status === "connected") {
+            expectTypeOf(crm.instanceUrl).toEqualTypeOf();
+        }
+        else {
+            expectTypeOf(crm.connectUrl).toEqualTypeOf();
+        }
+    });
+});
+describe("the untyped zitejs/integrations client", () => {
+    it("takes any name; only accessToken is certain", async () => {
+        const entry = await untyped.get("anything");
+        if (entry.status === "connected") {
+            expectTypeOf(entry.accessToken).toEqualTypeOf();
+            expectTypeOf(entry.instanceUrl).toEqualTypeOf();
+        }
+    });
+});
+describe("CREDENTIAL_FIELDS", () => {
+    it("is keyed by service type, and a string narrows to one", () => {
+        expectTypeOf(CREDENTIAL_FIELDS.salesforce).toEqualTypeOf();
+        const type = "salesforce";
+        // @ts-expect-error a plain string is not a service type
+        void CREDENTIAL_FIELDS[type];
+        if (isCredentialServiceType(type)) {
+            expectTypeOf(CREDENTIAL_FIELDS[type]).toEqualTypeOf();
+        }
+    });
+});

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

@@ -0,0 +1,3 @@
+import { type Connected, type NeedsConnect } from "./client.js";
+export type { Connected, NeedsConnect } from "./client.js";
+export declare const integrations: import("./client.js").IntegrationsClient<Record<string, NeedsConnect | Connected<Partial<Record<string, string>>>>>;

package/dist/esm/integrations/index.js

@@ -0,0 +1,3 @@
+import { createIntegrationsClient, } from "./client.js";
+// What code with no generated `.zite/integrations/index.ts` gets, e.g. a repo-root script.
+export const integrations = createIntegrationsClient();

package/dist/esm/integrations/rules.d.ts

@@ -0,0 +1,67 @@
+declare const FIELDS_BY_TYPE: {
+    googleCalendar: readonly string[];
+    googleDrive: readonly string[];
+    gmail: readonly string[];
+    googleDocs: readonly string[];
+    hubspot: readonly string[];
+    salesforce: readonly string[];
+    twilio: readonly string[];
+    slack: readonly string[];
+    linear: readonly string[];
+    openai: readonly string[];
+    googlesheets: readonly string[];
+    microsoftTeams: readonly string[];
+    onedrive: readonly string[];
+    outlook: readonly string[];
+    intercom: readonly string[];
+    mailchimp: readonly string[];
+    anthropic: readonly string[];
+    gemini: readonly string[];
+    stripe: readonly string[];
+    trello: readonly string[];
+    notion: readonly string[];
+    facebookPages: readonly string[];
+    monday: readonly string[];
+    resend: readonly string[];
+    clickhouse: readonly string[];
+    amplitude: readonly string[];
+    elevenlabs: readonly string[];
+    brevo: readonly string[];
+    calendly: readonly string[];
+    asana: readonly string[];
+    xero: readonly string[];
+    googleForms: readonly string[];
+    linkedin: readonly string[];
+    github: readonly string[];
+    quickbooks: readonly string[];
+    firecrawl: readonly string[];
+    jira: readonly string[];
+    typeform: readonly string[];
+    apollo: readonly string[];
+    attio: readonly string[];
+};
+/** A service type `integrations.get` serves: one used through its npm package with a token. */
+export type CredentialServiceType = keyof typeof FIELDS_BY_TYPE;
+/** Per service type: `accessToken`, then its extra labels sorted (Salesforce `instanceUrl`). */
+export declare const CREDENTIAL_FIELDS: Readonly<Record<CredentialServiceType, readonly string[]>>;
+/**
+ * Types the runtime never serves: those with a generated client (Airtable, email,
+ * the project database, Fillout) and those whose key is a frontend value (Maps, Analytics).
+ */
+export declare const NON_CREDENTIAL_SERVICE_TYPES: readonly string[];
+export declare const normalizeIntegrationServiceType: (type: string) => string;
+export declare const isCredentialServiceType: (type: string) => type is CredentialServiceType;
+/** One entry `integrations.get` can name from a source dir. */
+export type GettableIntegration = {
+    name: string;
+    serviceType: CredentialServiceType;
+};
+export type ConfigIntegrations = Readonly<Record<string, {
+    type?: unknown;
+} | undefined>>;
+/**
+ * The entries a source dir can name, by name: its own, then the workspace's under
+ * keys it has not taken. An entry whose type the runtime would not serve is dropped.
+ */
+export declare const gettableIntegrations: (rootIntegrations: ConfigIntegrations | undefined, appIntegrations?: ConfigIntegrations) => GettableIntegration[];
+export {};

package/dist/esm/integrations/rules.js

@@ -0,0 +1,98 @@
+// Which `zite.config.json` entries `integrations.get` can name, and the fields
+// each answers with. No imports, so the platform applies these same rules.
+const extras = (...labels) => [
+    "accessToken",
+    ...[...labels].sort(),
+];
+const FIELDS_BY_TYPE = {
+    googleCalendar: extras(),
+    googleDrive: extras(),
+    gmail: extras(),
+    googleDocs: extras(),
+    hubspot: extras(),
+    salesforce: extras("instanceUrl"),
+    twilio: extras("authToken"),
+    slack: extras(),
+    linear: extras(),
+    openai: extras(),
+    googlesheets: extras(),
+    microsoftTeams: extras(),
+    onedrive: extras(),
+    outlook: extras(),
+    intercom: extras(),
+    mailchimp: extras("server"),
+    anthropic: extras(),
+    gemini: extras(),
+    stripe: extras(),
+    trello: extras("clientApiKey"),
+    notion: extras(),
+    facebookPages: extras(),
+    monday: extras(),
+    resend: extras(),
+    clickhouse: extras("url", "username"),
+    amplitude: extras("apiKey"),
+    elevenlabs: extras(),
+    brevo: extras(),
+    calendly: extras(),
+    asana: extras(),
+    xero: extras("tenantId"),
+    googleForms: extras(),
+    linkedin: extras("personUrn"),
+    github: extras(),
+    quickbooks: extras("realmId", "apiBaseUrl"),
+    firecrawl: extras(),
+    jira: extras("cloudId", "siteUrl"),
+    typeform: extras(),
+    apollo: extras(),
+    attio: extras(),
+};
+/** Per service type: `accessToken`, then its extra labels sorted (Salesforce `instanceUrl`). */
+export const CREDENTIAL_FIELDS = FIELDS_BY_TYPE;
+/**
+ * Types the runtime never serves: those with a generated client (Airtable, email,
+ * the project database, Fillout) and those whose key is a frontend value (Maps, Analytics).
+ */
+export const NON_CREDENTIAL_SERVICE_TYPES = [
+    "airtable",
+    "databases",
+    "email",
+    "fillout",
+    "googleAnalytics",
+    "googlemaps",
+];
+/** Spellings older configs, or an agent writing the entry's slug, put in `type`. */
+const LEGACY_SERVICE_TYPES = {
+    googlecalendar: "googleCalendar",
+    "google-drive": "googleDrive",
+    "google-docs": "googleDocs",
+    "google-calendar": "googleCalendar",
+    "google-sheets": "googlesheets",
+    "google-analytics": "googleAnalytics",
+    "google-maps": "googlemaps",
+    "microsoft-teams": "microsoftTeams",
+    "one-drive": "onedrive",
+};
+// Own keys only: a name like `constructor` must not match Object.prototype.
+const hasOwn = (record, key) => Object.prototype.hasOwnProperty.call(record, key);
+export const normalizeIntegrationServiceType = (type) => hasOwn(LEGACY_SERVICE_TYPES, type) ? LEGACY_SERVICE_TYPES[type] : type;
+export const isCredentialServiceType = (type) => hasOwn(FIELDS_BY_TYPE, type);
+/**
+ * The entries a source dir can name, by name: its own, then the workspace's under
+ * keys it has not taken. An entry whose type the runtime would not serve is dropped.
+ */
+export const gettableIntegrations = (rootIntegrations, appIntegrations) => {
+    const own = appIntegrations ?? {};
+    const workspace = rootIntegrations ?? {};
+    const visible = [];
+    for (const [name, entry] of [
+        ...Object.entries(own),
+        ...Object.entries(workspace).filter(([name]) => !hasOwn(own, name)),
+    ]) {
+        if (typeof entry?.type !== "string")
+            continue;
+        const serviceType = normalizeIntegrationServiceType(entry.type);
+        if (isCredentialServiceType(serviceType))
+            visible.push({ name, serviceType });
+    }
+    return visible.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+};

package/dist/esm/integrations/rules.test.d.ts

@@ -0,0 +1 @@
+export {};