zitejs 0.10.0-start.7 → 0.10.0-start.8

package/dist/esm/start/data/transformations.js

@@ -0,0 +1,318 @@
+/**
+ * Database Record Transformation Utilities
+ *
+ * Shared transformation functions for converting between:
+ * - SDK field names ↔ database field IDs
+ * - LLM-friendly formats ↔ database formats
+ *
+ * Used by both workflow-runner and cloudflare-lambda.
+ */
+// =============================================================================
+// Reverse Lookup Helpers
+// =============================================================================
+/**
+ * Build reverse lookup map: sdkName → fieldId
+ */
+export function buildSdkNameToFieldIdMap(fieldMappings) {
+    const map = {};
+    if (!fieldMappings)
+        return map;
+    for (const [fieldId, fieldInfo] of Object.entries(fieldMappings)) {
+        if (fieldInfo?.mapping?.sdkName) {
+            map[fieldInfo.mapping.sdkName] = fieldId;
+            // Also add lowercase version for case-insensitive lookup
+            map[fieldInfo.mapping.sdkName.toLowerCase()] = fieldId;
+        }
+    }
+    return map;
+}
+// =============================================================================
+// Filter Transformations
+// =============================================================================
+/**
+ * Transform SDK field names to database field IDs in filters
+ */
+export function transformFiltersToFieldIds(filters, fieldMappings) {
+    if (!fieldMappings)
+        return filters;
+    const sdkNameToFieldId = buildSdkNameToFieldIdMap(fieldMappings);
+    const transformed = {};
+    for (const [key, value] of Object.entries(filters)) {
+        const fieldId = sdkNameToFieldId[key] || sdkNameToFieldId[key.toLowerCase()] || key;
+        transformed[fieldId] = value;
+    }
+    return transformed;
+}
+// =============================================================================
+// Formula Expression Transformations
+// =============================================================================
+/**
+ * Transform SDK field names to database field IDs inside a formula expression.
+ *
+ * The base-runner formula evaluator only accepts display names or field IDs
+ * in `{fieldRef}` placeholders — never SDK names. The LLM, however, sees the
+ * codebase through the SDK (camelCase fields like `count`), so it naturally
+ * writes `{count}` in expressions. This rewrite normalizes those references
+ * to field IDs at the SDK boundary, mirroring how `transformFiltersToFieldIds`
+ * normalizes filter keys.
+ *
+ * Behavior:
+ * - `{sdkName}` → `{fieldId}` when sdkName matches a field in `fieldMappings`
+ * - `{fieldId}` → unchanged (already a valid id)
+ * - `{anything else}` → unchanged (let the formula validator reject with a
+ *   clear, table-specific error message)
+ * - `{linkField.targetField}` (cross-table) → unchanged (target field lives
+ *   in another table; resolving it requires a separate per-link mapping
+ *   that the SDK boundary doesn't have)
+ */
+export function transformFormulaExpressionToFieldIds(expression, fieldMappings) {
+    if (!fieldMappings)
+        return expression;
+    const sdkNameToFieldId = buildSdkNameToFieldIdMap(fieldMappings);
+    const knownFieldIds = new Set(Object.keys(fieldMappings));
+    return expression.replace(/\{([^}]+)\}/g, (match, ref) => {
+        if (ref.includes('.'))
+            return match;
+        if (knownFieldIds.has(ref))
+            return match;
+        const fieldId = sdkNameToFieldId[ref] ?? sdkNameToFieldId[ref.toLowerCase()];
+        return fieldId ? `{${fieldId}}` : match;
+    });
+}
+// =============================================================================
+// Record Input Transformations (SDK → Database)
+// =============================================================================
+/**
+ * Transform record data to use field IDs instead of field names.
+ *
+ * LLMs often use human-readable field names, but the database expects field IDs.
+ * Uses a three-step fallback:
+ * 1. Check if key is already a valid field ID
+ * 2. Match by field name (case-insensitive)
+ * 3. Match by SDK name from field mappings
+ *
+ * @param recordData - The record data with potentially mixed keys
+ * @param table - Table definition for field name lookups (optional)
+ * @param fieldMappings - SDK name mappings (optional)
+ */
+export function transformFieldNamesToIds(recordData, table, fieldMappings) {
+    if (!recordData)
+        return recordData;
+    // If no table definition, fall back to simple SDK name mapping
+    if (!table) {
+        return transformRecordToFieldIds(recordData, fieldMappings);
+    }
+    const transformedRecord = {};
+    for (const [key, value] of Object.entries(recordData)) {
+        // Step 1: Check if it's already a field ID
+        const existsAsFieldId = table.fields.some(f => f.id === key);
+        if (existsAsFieldId) {
+            transformedRecord[key] = value;
+            continue;
+        }
+        // Step 2: Try to find field by name (case-insensitive)
+        const fieldByName = table.fields.find(f => f.name.toLowerCase() === key.toLowerCase());
+        if (fieldByName) {
+            transformedRecord[fieldByName.id] = value;
+            continue;
+        }
+        // Step 3: Try using field mappings (SDK name to field ID)
+        if (fieldMappings) {
+            const fieldId = Object.keys(fieldMappings).find(id => fieldMappings[id]?.mapping?.sdkName?.toLowerCase() ===
+                key.toLowerCase());
+            if (fieldId) {
+                transformedRecord[fieldId] = value;
+                continue;
+            }
+        }
+        // If no mapping found, keep the original key (might be a valid field ID)
+        transformedRecord[key] = value;
+    }
+    return transformedRecord;
+}
+/**
+ * Simple transformation using only field mappings (no table definition).
+ * Used when table metadata is not available.
+ */
+export function transformRecordToFieldIds(recordData, fieldMappings) {
+    if (!recordData || !fieldMappings)
+        return recordData;
+    const sdkNameToFieldId = buildSdkNameToFieldIdMap(fieldMappings);
+    const result = {};
+    for (const [key, value] of Object.entries(recordData)) {
+        // Skip id field
+        if (key === 'id' || key === 'recordID') {
+            continue;
+        }
+        const fieldId = sdkNameToFieldId[key] || sdkNameToFieldId[key.toLowerCase()] || key;
+        result[fieldId] = value;
+    }
+    return result;
+}
+/**
+ * Transform linked record fields to ensure they are arrays.
+ *
+ * Handles common LLM mistakes:
+ * - Passing a string instead of an array of record IDs
+ * - Passing null/undefined instead of an empty array
+ * - Passing literal strings like "null" or "undefined"
+ *
+ * @param recordData - Record data (should already have field IDs as keys)
+ * @param table - Table definition for field type lookups
+ */
+export function transformLinkedRecordFields(recordData, table) {
+    if (!recordData || !table)
+        return recordData;
+    const transformedRecord = {};
+    for (const [key, value] of Object.entries(recordData)) {
+        const field = table.fields.find(f => f.id === key);
+        if (field?.type === 'linked_record') {
+            if (typeof value === 'string') {
+                // Filter out LLM-generated placeholder strings
+                const cleanValue = value.trim();
+                if (cleanValue === '' ||
+                    cleanValue === 'null' ||
+                    cleanValue === 'undefined') {
+                    transformedRecord[key] = [];
+                }
+                else {
+                    transformedRecord[key] = [cleanValue];
+                }
+            }
+            else if (value == null) {
+                // Convert null/undefined to empty array
+                transformedRecord[key] = [];
+            }
+            else if (Array.isArray(value)) {
+                // Filter out any null/undefined/"null"/"undefined" entries
+                transformedRecord[key] = value.filter(v => v != null && v !== 'null' && v !== 'undefined');
+            }
+            else {
+                transformedRecord[key] = value;
+            }
+        }
+        else {
+            transformedRecord[key] = value;
+        }
+    }
+    return transformedRecord;
+}
+// =============================================================================
+// Record Output Transformations (Database → SDK)
+// =============================================================================
+/**
+ * Transform database record to use SDK field names
+ *
+ * @param record - Raw database record with field IDs
+ * @param fieldMappings - SDK name mappings
+ */
+export function transformRecordToSdkNames(record, fieldMappings) {
+    if (!record)
+        return undefined;
+    const result = { id: record.id };
+    if (!fieldMappings) {
+        const { id: _ignoredId, ...dataWithoutId } = record.data;
+        return { ...result, ...dataWithoutId };
+    }
+    for (const [fieldId, value] of Object.entries(record.data)) {
+        const mapping = fieldMappings[fieldId];
+        const sdkName = mapping?.mapping?.sdkName || fieldId;
+        if (sdkName === 'id') {
+            continue;
+        }
+        result[sdkName] = value;
+    }
+    return result;
+}
+// =============================================================================
+// Batch Transformations
+// =============================================================================
+/**
+ * Transform multiple records for input (SDK → Database)
+ */
+export function transformRecordsForInput(records, table, fieldMappings) {
+    return records.map(record => {
+        const withFieldIds = transformFieldNamesToIds(record, table, fieldMappings);
+        return transformLinkedRecordFields(withFieldIds, table);
+    });
+}
+/**
+ * Transform multiple records for output (Database → SDK)
+ */
+export function transformRecordsForOutput(records, fieldMappings) {
+    return records
+        .map(r => transformRecordToSdkNames(r, fieldMappings))
+        .filter((r) => r !== undefined);
+}
+/**
+ * Transform an array of SDK field names to field IDs.
+ *
+ * Used for the `fields` parameter in findOne/findAll to select which fields to return.
+ * Uses the same three-step fallback as transformFieldNamesToIds:
+ * 1. Check if name is already a valid field ID
+ * 2. Match by field name (case-insensitive)
+ * 3. Match by SDK name from field mappings
+ *
+ * @param fields - Array of SDK field names (e.g. ['customerName', 'email'])
+ * @param table - Table definition for field name lookups (optional)
+ * @param fieldMappings - SDK name mappings (optional)
+ * @returns Array of field IDs, or undefined if input is undefined
+ */
+export function transformFieldsToFieldIds(fields, table, fieldMappings) {
+    if (!fields)
+        return undefined;
+    const sdkNameToFieldId = buildSdkNameToFieldIdMap(fieldMappings);
+    return fields.map(name => {
+        // Step 1: Check if it's already a field ID
+        if (table?.fields.some(f => f.id === name)) {
+            return name;
+        }
+        // Step 2: Match by human-readable field name (case-insensitive)
+        if (table) {
+            const fieldByName = table.fields.find(f => f.name.toLowerCase() === name.toLowerCase());
+            if (fieldByName)
+                return fieldByName.id;
+        }
+        // Step 3: Match by SDK name from field mappings
+        return (sdkNameToFieldId[name] || sdkNameToFieldId[name.toLowerCase()] || name);
+    });
+}
+/**
+ * Resolve the field references in a sort spec to field IDs.
+ *
+ * Sort arrives from app code using SDK names (`closeDate`), but base-runner
+ * resolves sort fields by field ID or display name only, and silently skips one
+ * it cannot match. Running the references through the same resolution order as
+ * `fields` is what makes a sort on a multi-word field ("Close date" ->
+ * `closeDate`) actually apply instead of being dropped without an error.
+ *
+ * System sort fields (`id`, `createdAt`, `updatedAt`) have no mapping and fall
+ * through unchanged, which is what base-runner expects.
+ */
+export function transformSortToFieldIds(sort, table, fieldMappings) {
+    if (!sort)
+        return undefined;
+    const entries = typeof sort === 'string'
+        ? [{ field: sort, direction: 'asc' }]
+        : sort;
+    if (entries.length === 0)
+        return undefined;
+    const resolved = transformFieldsToFieldIds(entries.map(entry => entry.field), table, fieldMappings);
+    return entries.map((entry, index) => ({
+        field: resolved?.[index] ?? entry.field,
+        direction: entry.direction ?? 'asc',
+    }));
+}
+/**
+ * Transform matchOn field names to field IDs
+ */
+export function transformMatchOnFields(matchOn, fieldMappings) {
+    if (!matchOn || !fieldMappings)
+        return matchOn;
+    const sdkNameToFieldId = buildSdkNameToFieldIdMap(fieldMappings);
+    return matchOn.map(fieldName => {
+        return (sdkNameToFieldId[fieldName] ||
+            sdkNameToFieldId[fieldName.toLowerCase()] ||
+            fieldName);
+    });
+}

package/dist/esm/start/data/types.d.ts

@@ -0,0 +1,91 @@
+export type BaseTable = {
+    id: string;
+    name: string;
+    deletedAt?: string | null;
+    fields: Array<{
+        id: string;
+        name: string;
+        type: string;
+        deletedAt?: string | null;
+        template?: {
+            tableId?: string;
+            isInverse?: boolean;
+        } & Record<string, unknown>;
+    }>;
+};
+export type GetBaseResponseType = {
+    id: string;
+    name: string;
+    tables: BaseTable[];
+};
+export interface FindOneResponseType {
+    id: string;
+    data: Record<string, unknown>;
+    fields?: Record<string, unknown>;
+}
+export interface FindAllResponseType {
+    records: FindOneResponseType[];
+    offset?: string;
+    hasMore: boolean;
+    total?: number;
+}
+export interface BulkCreateResponseType {
+    success?: boolean;
+    records: FindOneResponseType[];
+}
+export type LegacyRecordsFilterClauseType = Record<string, unknown>;
+/** Simplified table definition for SDK transformations. */
+export interface SimpleTableDefinition {
+    id: string;
+    name: string;
+    fields: Array<{
+        id: string;
+        name: string;
+        type: string;
+        template?: unknown;
+    }>;
+}
+/** Field mappings for transforming between SDK names and field IDs */
+export type FieldMappings = Record<string, {
+    mapping: {
+        sdkName: string;
+    };
+}>;
+/** A record after transformation. */
+export interface DatabaseRecord {
+    id: string;
+    [key: string]: unknown;
+}
+/** The build's tables' and fields' SDK names, by id (`projectConfig.nameMappings`). */
+export type DataNameMappings = {
+    tables: Record<string, {
+        mapping: {
+            sdkName: string;
+        };
+        fields: Record<string, {
+            mapping: {
+                sdkName: string;
+            };
+        }>;
+    }>;
+};
+/** base-runner's rename map for SQL, which `buildSdkNameMappingsForBase` builds. */
+export interface NameMappings {
+    tables: Record<string, {
+        displayName: string;
+        fields: Record<string, string>;
+    }>;
+    linkTables: Record<string, {
+        displayName: string;
+        sourceIdColumnAlias: string;
+        targetIdColumnAlias: string;
+    }>;
+}
+/** Marks an error as our fault rather than the app's. */
+export declare const ZITE_PLATFORM_FAULT_FLAG = "zitePlatformFault";
+/** base-runner's refusal, with its status. */
+export declare class DatabasesApiError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    constructor(message: string, statusCode: number, statusText: string);
+}

package/dist/esm/start/data/types.js

@@ -0,0 +1,14 @@
+// Ported from restly's packages/workflow-edge/src/databases/types.ts: the shapes base-runner answers with.
+/** Marks an error as our fault rather than the app's. */
+export const ZITE_PLATFORM_FAULT_FLAG = "zitePlatformFault";
+/** base-runner's refusal, with its status. */
+export class DatabasesApiError extends Error {
+    statusCode;
+    statusText;
+    constructor(message, statusCode, statusText) {
+        super(message);
+        this.name = "DatabasesApiError";
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+    }
+}

package/dist/esm/start/server.js

@@ -3,6 +3,8 @@ import { describeApp } from "./describe.js";
 import { runRegistration } from "./registration.js";
 import { isAuthHookName, loadAuthHooks } from "./authHooks.js";
 import { errorOf, preview } from "./runLog.js";
+import { DATA_INTEGRATION_ID, dataContextOf, runDataCall } from "./data/index.js";
+import { airtableSettingsOf, runAirtableCall } from "./airtable/index.js";
 import { getHost, requireScope, runInScope, runWithHost } from "./scope.js";
 import { ZITEJS_VERSION } from "./version.js";
 import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
@@ -22,7 +24,20 @@ export function installPlatformTransport() {
         if (!host?.platform)
             throw new Error("The Zite platform binding is missing");
         host.session ??= Promise.resolve(host.watch ? host.platform.session(host.watch) : host.platform.session());
-        const result = await (await host.session).call({ integrationId, className, methodName, params, access: scope.kind });
+        const session = await host.session;
+        if (integrationId === DATA_INTEGRATION_ID) {
+            const found = await dataContextOf(session);
+            if (found) {
+                return recordCall(host, { integrationId, className, methodName, params }, () => runDataCall(session, found, host.mode, methodName, params));
+            }
+        }
+        else if (!integrationId.startsWith("__")) {
+            const airtable = await airtableSettingsOf(session, integrationId);
+            if (airtable) {
+                return recordCall(host, { integrationId, className, methodName, params }, () => runAirtableCall(host, session, integrationId, airtable, methodName, params, scope.kind));
+            }
+        }
+        const result = await session.call({ integrationId, className, methodName, params, access: scope.kind });
         if ("value" in result)
             return result.value;
         const { code, message, userFacingMessage } = result.error;
@@ -31,6 +46,27 @@ export function installPlatformTransport() {
     globalThis.__wrapSdkCall = sdkCall;
     watchOutboundFetches();
 }
+/** A data call the app made itself, recorded as the host recorded the ones it made. */
+const recordCall = async (host, call, run) => {
+    const at = Date.now();
+    const record = {
+        integrationId: call.integrationId,
+        className: call.className,
+        methodName: call.methodName,
+        at,
+        inputs: preview(call.params),
+    };
+    try {
+        const value = await run();
+        (host.calls ??= []).push({ ...record, durationMs: Date.now() - at, outputs: preview(value) });
+        return value;
+    }
+    catch (error) {
+        const { code, message } = errorOf(error);
+        (host.calls ??= []).push({ ...record, durationMs: Date.now() - at, error: { code, message } });
+        throw error;
+    }
+};
 let fetchesWatched = false;
 const fetchedHost = (input) => {
     try {
@@ -69,13 +105,16 @@ export function hostContextFromProps(request, props) {
         appUrl: props.appUrl,
         baseId: props.baseId,
         previewClaim: props.previewClaim,
+        env: props.env,
         runs: [],
         platform: props.platform,
     };
 }
 // Classic sets these per run. Node and workerd both refuse getters on process.env, so each request writes what the
 // host sent, which is the same for every request a build serves: the live URL even on a demo.
-const setRequestEnv = ({ appUrl, baseId }) => {
+// The connection vars the last request set, so one gone since (an integration removed) doesn't linger.
+let connectionEnvKeys = new Set();
+const setRequestEnv = ({ appUrl, baseId, env: connectionEnv }) => {
     const env = globalThis.process?.env;
     if (!env)
         return;
@@ -83,6 +122,16 @@ const setRequestEnv = ({ appUrl, baseId }) => {
         env.ZITE_APP_URL = appUrl;
     if (baseId)
         env.ZITE_BASE_ID = baseId;
+    if (!connectionEnv)
+        return;
+    for (const key of connectionEnvKeys)
+        if (!Object.hasOwn(connectionEnv, key))
+            delete env[key];
+    for (const [key, value] of Object.entries(connectionEnv)) {
+        if (key.startsWith("ZITE_"))
+            env[key] = value;
+    }
+    connectionEnvKeys = new Set(Object.keys(connectionEnv));
 };
 /**
  * A request the host didn't dispatch: the host's warm-up, `zitejs describe` under `vite preview`, and tests. Only the
@@ -241,14 +290,14 @@ export function createZiteHandlers(options) {
             response = new Response(response.body, { status, headers: response.headers });
         return onBodyEnd(response, () => {
             const { platform } = host;
-            if ((!host.runs.length && !host.pending?.length) || !platform)
+            if ((!host.runs.length && !host.calls?.length && !host.pending?.length) || !platform)
                 return;
             // On the request's session when it has one: one call, not another binding round trip.
             const flushed = (async () => {
                 await Promise.all(host.pending ?? []);
-                if (!host.runs.length)
+                if (!host.runs.length && !host.calls?.length)
                     return;
-                const batch = { runs: host.runs };
+                const batch = { runs: host.runs, ...(host.calls?.length && { calls: host.calls }) };
                 const session = host.session ? await host.session : undefined;
                 await (session?.runs ? session.runs(batch) : platform.runs(batch));
             })().catch((error) => {

package/dist/esm/start/types.d.ts

@@ -53,12 +53,44 @@ export type PlatformCallResult = {
         userFacingMessage?: string;
     };
 };
+/** One data call the app's own dispatch made, for its run's detail. */
+export type CallRecord = {
+    integrationId: string;
+    className: string;
+    methodName: string;
+    at: number;
+    durationMs: number;
+    inputs?: string;
+    outputs?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+};
 export type PlatformSession = {
     call(call: PlatformCallInput): Promise<PlatformCallResult>;
     /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it. */
     runs?(batch: {
         runs: RunRecord[];
+        calls?: CallRecord[];
     }): Promise<void>;
+    /** The build's base and SDK names, which the app's data dispatch translates against. */
+    dataContext?(): Promise<{
+        baseId: string | null;
+        nameMappings: unknown;
+    }>;
+    /** One base-runner request; the host holds it to the build's base and adds the key and acting user. */
+    dataFetch?(request: {
+        method: string;
+        path: string;
+        body?: string;
+    }): Promise<Response>;
+    /** An integration's settings as the build declares them; null for one it doesn't, or that runs on the platform. */
+    integrationSettings?(integrationId: string): Promise<{
+        serviceType: string;
+        baseId?: string;
+        nameMappings?: unknown;
+    } | null>;
 };
 /**
  * The host's ear on a page render it may cache, from `render()`. Reports can
@@ -95,6 +127,8 @@ export type HostProps = {
     baseId?: string;
     /** An editor preview's access, which zitejs keeps on the app's links and calls. */
     previewClaim?: string;
+    /** `process.env` as classic sets it: connections' vars, secrets as placeholders egress swaps but S3's, then the user's own secrets. */
+    env?: Record<string, string>;
 };
 /** What the host resolved for this request. Set by the generated server entry, never by the browser. */
 export type ZiteRequestContext = {
@@ -106,8 +140,14 @@ export type ZiteRequestContext = {
     appUrl?: string;
     baseId?: string;
     previewClaim?: string;
+    /** Classic's connection env vars the host sent, set into `process.env` for the request. */
+    env?: Record<string, string>;
     /** Filled by run capture, flushed to the platform once the response ends. */
     runs: RunRecord[];
+    /** The data calls this request made, flushed with its runs. */
+    calls?: CallRecord[];
+    /** This request's Airtable reads, so the same one twice goes out once. */
+    airtableReads?: Map<string, Promise<unknown>>;
     /** Records still reading a copy of a body; the flush waits for them. */
     pending?: Promise<void>[];
     platform?: PlatformBinding;

package/dist/esm/start/version.d.ts

@@ -1 +1 @@
-export declare const ZITEJS_VERSION = "0.10.0-start.7";
+export declare const ZITEJS_VERSION = "0.10.0-start.8";

package/dist/esm/start/version.js

@@ -1,2 +1,2 @@
 // Written by scripts/write-version.mjs from package.json.
-export const ZITEJS_VERSION = "0.10.0-start.7";
+export const ZITEJS_VERSION = "0.10.0-start.8";

package/dist/esm/start/vite.js

@@ -131,6 +131,8 @@ export function zite(options = {}) {
         },
     };
     return [
+        // First, so ids name lines in the source, before TanStack splits a route's component out of it.
+        ziteId(),
         tanstackStart({
             // TanStack resolves these from `src/`.
             server: { entry: `../${serverEntry.replace(/\.ts$/, "")}` },
@@ -163,7 +165,6 @@ export function zite(options = {}) {
         }),
         options.cloudflare !== false ? loadCloudflare(serverEntry) : null,
         viteReact(),
-        ziteId(),
         compileZitejs,
         functionIds,
         workflowRegistry,

package/dist/esm/sync/lib.js

@@ -71,6 +71,7 @@ const FIELD_TYPE_MAP = {
     formula: "any",
     created_at: "string",
     updated_at: "string",
+    created_by: "string",
     updated_by: "string",
 };
 /**
@@ -96,7 +97,7 @@ const FIELD_INPUT_TYPE_MAP = {
  * rather than typed and then refused at runtime.
  *
  * Mirrors `COMPUTED_FIELD_TYPES` in the product's own `shared/bases/fields`.
- * The first six are rejected by `createRecordDataSchema` — each has a
+ * The first seven are rejected by `createRecordDataSchema` — each has a
  * `refine(val => val == null)`, so a non-null write errors (null is a no-op
  * clear). `created_at` / `updated_at` are refused differently: they have no
  * column at all, so a write is silently dropped, which is the worse outcome to
@@ -108,6 +109,7 @@ const READ_ONLY_FIELD_TYPES = new Set([
     "source",
     "formula",
     "autonumber",
+    "created_by",
     "updated_by",
     "created_at",
     "updated_at",
@@ -245,13 +247,8 @@ function fieldJsdoc(schemaField, table, schema) {
     const parts = [];
     if (table.primaryFieldId === schemaField.id)
         parts.push("Primary field");
-    if (def.type === "created_at" ||
-        def.type === "updated_at" ||
-        def.type === "lookup" ||
-        def.type === "formula" ||
-        def.type === "autonumber") {
+    if (READ_ONLY_FIELD_TYPES.has(def.type))
         parts.push("Read-only");
-    }
     if (def.type === "linked_record") {
         const tpl = def.template;
         if (tpl.tableId) {