@jd-data-limited/easy-fm 5.0.0-beta.2 → 5.0.0-beta.5

package/dist/records/getOperations/recordGetOperation.js

@@ -2,7 +2,6 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { LayoutRecord } from '../layoutRecord.js';
-import { ApiRecordResponseObj } from '../../models/apiResults.js';
 import { FMError } from '../../FMError.js';
 import { FindRequestSymbol } from '../../utils/query.js';
 import { Temporal } from "temporal-polyfill";
@@ -134,11 +133,11 @@ export class RecordGetOperation {
                     return item;
                 // Re-write date into correct format
                 if (item instanceof Temporal.PlainDateTime)
-                    return temporalToString(item, this.layout.database.host.timeStampFormat);
+                    return temporalToString(item, this.layout.database.timeStampFormat);
                 if (item instanceof Temporal.PlainDate)
-                    return temporalToString(item, this.layout.database.host.dateFormat);
+                    return temporalToString(item, this.layout.database.dateFormat);
                 if (item instanceof Temporal.PlainTime)
-                    return temporalToString(item, this.layout.database.host.timeFormat);
+                    return temporalToString(item, this.layout.database.timeFormat);
             }).join('');
         }
         return out;
@@ -164,23 +163,25 @@ export class RecordGetOperation {
     }
     async performFind(offset, limit) {
         await this.layout.getLayoutMeta();
-        const isFind = this.isFindRequest;
-        let endpoint = this.layout.endpoint + (isFind ? '/_find' : '/records');
-        if (!isFind)
-            endpoint += '?' + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
-        const reqData = {
-            // port: 443,
-            method: isFind ? 'POST' : 'GET',
-            type: ApiRecordResponseObj,
-            body: isFind ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined
-        };
         try {
-            const res = await this.layout.database.fetchJSON(endpoint, reqData);
-            // console.log("RESOLVING")
+            const portals = {};
+            for (const [name, paging] of Object.entries(this.portals))
+                if (paging)
+                    portals[name] = paging;
+            const scripts = {};
+            for (const [name, script] of Object.entries(this.scriptData))
+                if (script)
+                    scripts[name] = { name: script.name, parameter: script.parameter ?? '' };
+            const { value: res, binding } = await this.layout.database.execute({
+                type: 'record.list',
+                layout: this.layout.name,
+                query: this.requests.map(request => ({ fields: request.req, omit: request.omit ?? false })),
+                options: { limit, offset, sort: this.sortData, portals, scripts }
+            });
             if (!this.layout.metadata)
                 await this.layout.getLayoutMeta();
-            return res.data.map(item => {
-                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData);
+            return res.map(item => {
+                return new LayoutRecord(this.layout, item.recordId, item.modId, item.fieldData, item.portalData, [], binding);
             });
         }
         catch (e) {

package/dist/records/layoutRecord.d.ts

@@ -8,10 +8,12 @@ import { type ApiFieldData, ApiFieldMetadata, type ApiPortalData, type ApiRowDat
 import { type LayoutBase } from '../layouts/layoutBase.js';
 import z from 'zod';
 import { Field } from "./fields/field.js";
+import { ContainerField } from './fields/containerField.js';
+import { type SessionBinding } from '../connection/databaseProvider.js';
 export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT['fields']> implements LayoutRecordBase {
     portals: LAYOUT['portals'];
     private readonly portalsToInclude;
-    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: z.infer<typeof ApiFieldData>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>);
+    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: z.infer<typeof ApiFieldData>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>, sessionBinding?: SessionBinding);
     /** Returns all loaded portals on this record as an array. */
     get portalsArray(): Array<Portal<any>>;
     /**
@@ -31,11 +33,15 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
      * @throws {Error} If commit() has not been called.
      * @throws {FMError} If the retrieval fails.
      */
-    get(): Promise<this>;
+    get(portals?: Record<string, {
+        limit: number;
+        offset: number;
+    }>): Promise<this>;
     /** Creates a duplicate of this record in FileMaker. */
     duplicate(): Promise<LayoutRecord<LAYOUT>>;
     /** Deletes this record from FileMaker. */
     delete(): Promise<void>;
+    refreshContainer(fieldId: string): Promise<ContainerField>;
     /** Returns this record's edited fields as a FileMaker API payload. */
     fieldsToObject(filter?: (a: Field) => boolean): Omit<z.infer<typeof ApiRowDataDef>, 'portalData'>;
     /** Returns this record and its portal edits as a FileMaker API payload. */

package/dist/records/layoutRecord.js

@@ -5,14 +5,13 @@ import { RecordBase } from './recordBase.js';
 import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { FMError } from '../FMError.js';
-import { ApiRecordResponseObj } from '../models/apiResults.js';
-import z from 'zod';
 import { ValueFieldBase } from "./fields/valueField.js";
+import { ContainerField } from './fields/containerField.js';
 export class LayoutRecord extends RecordBase {
     portals = {};
     portalsToInclude;
-    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = []) {
-        super(layout, parseInt(recordId), parseInt(modId), fieldData);
+    constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = [], sessionBinding) {
+        super(layout, parseInt(recordId), parseInt(modId), fieldData, sessionBinding);
         this.portalsToInclude = portalsToInclude;
         if (portalData) {
             this.processPortalData(portalData);
@@ -32,62 +31,30 @@ export class LayoutRecord extends RecordBase {
         const data = this.toObject();
         delete data.recordId;
         delete data.modId;
-        if (extraBody.scripts?.after) {
-            data.script = extraBody.scripts.after.name;
-            if (extraBody.scripts.after.parameter)
-                data['script.param'] = extraBody.scripts.after.parameter;
-        }
-        if (extraBody.scripts?.prerequest) {
-            data['script.prerequest'] = extraBody.scripts.prerequest.name;
-            if (extraBody.scripts.prerequest.parameter)
-                data['script.prerequest.param'] = extraBody.scripts.prerequest.parameter;
-        }
-        if (extraBody.scripts?.presort) {
-            data['script.presort'] = extraBody.scripts.presort.name;
-            if (extraBody.scripts.presort.parameter)
-                data['script.presort.param'] = extraBody.scripts.presort.parameter;
-        }
         if (extraBody.options)
             data.options = extraBody.options;
         if (extraBody.deleteRelatedRecords)
-            data.fieldData.deleteRelated = extraBody.deleteRelatedRecords.map(i => `${i.table}.${i.recordId}`);
+            data.deleteRelatedRecords = extraBody.deleteRelatedRecords;
+        const options = operationOptions(extraBody);
         if (this.recordId === -1) {
             // This is a new LayoutRecord
-            const res = await this.layout.database.fetchJSON(`${this.layout.endpoint}/records`, {
-                method: 'POST',
-                body: JSON.stringify(data),
-                type: z.object({
-                    recordId: z.string(),
-                    modId: z.string(),
-                    scriptError: z.string().optional()
-                })
-            });
-            if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-                throw new FMError(res.scriptError, res.httpStatus, res);
+            const { value: res, binding } = await this.layout.database.execute({ type: 'record.create', layout: this.layout.name, body: data, options });
+            if (res.scriptError) {
+                throw new FMError(res.scriptError, res.status ?? 200, res);
             }
             this.recordId = parseInt(res.recordId);
             this.modId = parseInt(res.modId);
+            this.sessionBinding = binding;
             this._onSave();
             return this;
         }
         // for (let item of Object.keys(data)) extraBody[item] = data[item]
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'PATCH',
-            body: JSON.stringify(data),
-            type: z.object({
-                modId: z.string(),
-                newPortalRecordInfo: z.array(z.object({
-                    tableName: z.string(),
-                    recordId: z.string(),
-                    modId: z.string()
-                })).optional(),
-                scriptError: z.string().optional()
-            })
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res);
+        const { value: res, binding } = await this.layout.database.execute({ type: 'record.update', layout: this.layout.name, recordId: this.recordId, body: data, options });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res);
         }
         this.modId = +res.modId;
+        this.sessionBinding = binding;
         this._onSave();
         return this;
     }
@@ -107,7 +74,7 @@ export class LayoutRecord extends RecordBase {
                 const fieldData = item;
                 delete fieldData.recordId;
                 delete fieldData.modId;
-                return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData);
+                return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData, this.sessionBinding);
             });
             // @ts-expect-error - This code is actually correct, but throws a typescript error
             this.portals[portalName] = _portal;
@@ -121,55 +88,49 @@ export class LayoutRecord extends RecordBase {
      * @throws {Error} If commit() has not been called.
      * @throws {FMError} If the retrieval fails.
      */
-    async get() {
+    async get(portals = {}) {
         if (this.recordId === -1) {
             throw new Error('Cannot get this RecordBase until a commit() is done.');
         }
         if (!this.layout.metadata)
             await this.layout.getLayoutMeta();
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            type: ApiRecordResponseObj
-        });
+        const { value: record, binding } = await this.layout.database.execute({ type: 'record.get', layout: this.layout.name, recordId: this.recordId, options: { scripts: {}, portals } });
         // console.log(res, res.response.data)
-        this.modId = +res.data[0].modId;
-        this.processFieldData(res.data[0].fieldData);
+        this.sessionBinding = binding;
+        this.modId = +record.modId;
+        this.processFieldData(record.fieldData);
         this.portalData = [];
-        if (res.data[0].portalData)
-            this.processPortalData(res.data[0].portalData);
+        if (record.portalData)
+            this.processPortalData(record.portalData);
         return this;
     }
     /** Creates a duplicate of this record in FileMaker. */
     async duplicate() {
         const trace = new Error();
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'POST',
-            type: z.object({
-                recordId: z.string(),
-                modId: z.string(),
-                scriptError: z.string().optional()
-            })
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res, trace);
+        const { value: res, binding } = await this.layout.database.execute({ type: 'record.duplicate', layout: this.layout.name, recordId: this.recordId, options: emptyOperationOptions() });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res, trace);
         }
         const data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false);
-        const _res = new LayoutRecord(this.layout, res.recordId, res.modId, data.fieldData, data.portalData);
+        const _res = new LayoutRecord(this.layout, res.recordId, res.modId, data.fieldData, data.portalData, [], binding);
         this.emit('duplicated');
         return _res;
     }
     /** Deletes this record from FileMaker. */
     async delete() {
-        const res = await this.layout.database.fetchJSON(this.endpoint, {
-            method: 'DELETE',
-            type: z.object({
-                scriptError: z.string().optional()
-            }).optional()
-        });
-        if (typeof res.scriptError !== 'undefined' && res.scriptError !== '0') {
-            throw new FMError(res.scriptError, res.httpStatus, res);
+        const { value: res } = await this.layout.database.execute({ type: 'record.delete', layout: this.layout.name, recordId: this.recordId, options: emptyOperationOptions() });
+        if (res.scriptError) {
+            throw new FMError(res.scriptError, res.status ?? 200, res);
         }
         this.emit('deleted');
     }
+    async refreshContainer(fieldId) {
+        await this.get();
+        const field = this.fields[fieldId];
+        if (!(field instanceof ContainerField))
+            throw new Error(`Container field ${fieldId} was not returned while refreshing record`);
+        return field;
+    }
     /** Returns this record's edited fields as a FileMaker API payload. */
     fieldsToObject(filter = (a) => a instanceof ValueFieldBase && a.edited) {
         const fieldsProcessed = {};
@@ -201,3 +162,13 @@ export class LayoutRecord extends RecordBase {
         return obj;
     }
 }
+function emptyOperationOptions() {
+    return { scripts: {}, portals: {} };
+}
+function operationOptions(extra) {
+    const scripts = {};
+    for (const [name, script] of Object.entries(extra.scripts ?? {}))
+        if (script)
+            scripts[name] = { name: script.name, parameter: script.parameter ?? '' };
+    return { scripts, portals: {} };
+}

package/dist/records/portalRecord.d.ts

@@ -5,6 +5,8 @@ import z from "zod";
 import { ApiFieldMetadata } from "../models/apiResults.js";
 import { RecordFieldsMap } from "../layouts/layoutInterface.js";
 import { Field } from "./fields/field.js";
+import { ContainerField } from './fields/containerField.js';
+import { type SessionBinding } from '../connection/databaseProvider.js';
 /**
  * Represents a PortalRecord, which is a record in a portal within a parent record.
  * @template T - The type of the record's field map.
@@ -12,7 +14,8 @@ import { Field } from "./fields/field.js";
 export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<T> {
     readonly portal: PortalBase<T>;
     readonly type = RecordTypes.PORTAL;
-    constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {});
+    constructor(record: RecordBase<any>, portal: PortalBase<any>, recordId: number, modId?: number, fieldData?: {}, sessionBinding?: SessionBinding);
+    refreshContainer(fieldId: string): Promise<ContainerField>;
     _onSave(): void;
     /**
      * Commits the parent record, and in turn this one.

package/dist/records/portalRecord.js

@@ -3,6 +3,7 @@
  */
 import { RecordBase } from './recordBase.js';
 import { RecordTypes } from '../types.js';
+import { ContainerField } from './fields/containerField.js';
 /**
  * Represents a PortalRecord, which is a record in a portal within a parent record.
  * @template T - The type of the record's field map.
@@ -10,10 +11,19 @@ import { RecordTypes } from '../types.js';
 export class PortalRecord extends RecordBase {
     portal;
     type = RecordTypes.PORTAL;
-    constructor(record, portal, recordId, modId = recordId, fieldData = {}) {
-        super(record.layout, recordId, modId, fieldData);
+    constructor(record, portal, recordId, modId = recordId, fieldData = {}, sessionBinding) {
+        super(record.layout, recordId, modId, fieldData, sessionBinding);
         this.portal = portal;
     }
+    async refreshContainer(fieldId) {
+        await this.portal.record.get({ [this.portal.name]: { offset: 1, limit: Math.max(1, this.portal.records.length) } });
+        const portal = this.portal.record.portalsArray.find(item => item.name === this.portal.name);
+        const record = portal?.records.find(item => item.recordId === this.recordId);
+        const field = record?.fields[fieldId];
+        if (!(field instanceof ContainerField))
+            throw new Error(`Container field ${fieldId} was not returned while refreshing record`);
+        return field;
+    }
     _onSave() {
         super._onSave();
         this.portal.record._onSave();

package/dist/records/recordBase.d.ts

@@ -1,10 +1,12 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { RecordTypes } from '../types.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
 import { type ApiFieldData, type ApiFieldMetadata } from '../models/apiResults.js';
 import { type z } from 'zod';
 import { RecordFieldsMap } from "../layouts/layoutInterface.js";
 import { Field } from "./fields/field.js";
+import { ContainerField } from "./fields/containerField.js";
+import { type SessionBinding } from '../connection/databaseProvider.js';
 export declare abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
     readonly type: RecordTypes;
@@ -17,8 +19,8 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
      */
     fields: T;
     protected portalData: any[];
-    protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: z.infer<typeof ApiFieldData>);
-    get endpoint(): string;
+    sessionBinding?: SessionBinding;
+    protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: z.infer<typeof ApiFieldData>, sessionBinding?: SessionBinding);
     /**
      * A boolean indicating whether this record has been modified and should be committed
      *
@@ -27,6 +29,7 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
     get edited(): boolean;
     get fieldsArray(): Array<Field>;
     abstract getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
+    abstract refreshContainer(fieldId: string): Promise<ContainerField>;
     protected processFieldData(fieldData: z.infer<typeof ApiFieldData>): T;
     _onSave(): void;
 }

package/dist/records/recordBase.js

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { RecordTypes } from '../types.js';
 import { DateField, NumberField, TextField, TimeField, TimeStampField, ValueFieldBase } from "./fields/valueField.js";
 import { ContainerField } from "./fields/containerField.js";
@@ -17,16 +17,15 @@ export class RecordBase extends EventEmitter {
      */
     fields;
     portalData = [];
-    constructor(layout, recordId, modId = recordId, fieldData) {
+    sessionBinding;
+    constructor(layout, recordId, modId = recordId, fieldData, sessionBinding) {
         super();
         this.layout = layout;
         this.recordId = recordId;
         this.modId = modId;
+        this.sessionBinding = sessionBinding;
         this.fields = this.processFieldData(fieldData);
     }
-    get endpoint() {
-        return `${this.layout.endpoint}/records/${this.recordId}`;
-    }
     /**
      * A boolean indicating whether this record has been modified and should be committed
      *
@@ -36,6 +35,8 @@ export class RecordBase extends EventEmitter {
         return !!this.fieldsArray.find(i => i instanceof ValueFieldBase && i.edited);
     }
     get fieldsArray() {
+        // Generated layout types may expose a narrower read-only view, while
+        // runtime records always contain concrete Field instances.
         return Object.values(this.fields);
     }
     processFieldData(fieldData) {

package/dist/schema.d.ts

@@ -0,0 +1,54 @@
+import type { DatabaseProvider } from './connection/databaseProvider.js';
+import type { Field } from './records/fields/field.js';
+export type ReadonlyField<T extends Field> = T extends Field ? Omit<T, 'set' | 'upload' | 'value'> & {
+    readonly value: T['value'];
+} : never;
+export interface ValidationIssue {
+    path: PropertyKey[];
+    message: string;
+    code?: string;
+}
+export type ValidationResult = {
+    success: true;
+} | {
+    success: false;
+    issues: ValidationIssue[];
+    cause?: unknown;
+};
+export interface RuntimeValidator {
+    validate(schema: unknown, value: unknown): ValidationResult;
+}
+/** Built-in runtime adapter used by Zod-generated clients. */
+export declare const zodValidator: RuntimeValidator;
+export interface ExpectedFieldMetadata {
+    result: string;
+    type: string;
+}
+export interface LayoutRuntimeSchema {
+    /** Validates the complete canonical ProviderRecord returned by a provider. */
+    record: unknown;
+    metadata?: {
+        fields: Record<string, ExpectedFieldMetadata>;
+        portals: Record<string, Record<string, ExpectedFieldMetadata>>;
+    };
+}
+export interface DatabaseRuntimeSchema {
+    validator: RuntimeValidator;
+    layouts: Record<string, LayoutRuntimeSchema>;
+}
+export declare class SchemaDriftError extends Error {
+    readonly layout: string;
+    readonly recordId?: string;
+    readonly portal?: string;
+    readonly phase: 'metadata' | 'record' | 'portal';
+    readonly issues: ValidationIssue[];
+    constructor(options: {
+        layout: string;
+        recordId?: string;
+        portal?: string;
+        phase?: SchemaDriftError['phase'];
+        issues: ValidationIssue[];
+    }, cause?: unknown);
+}
+/** Decorates any provider with generated, provider-neutral metadata and result validation. */
+export declare function withSchemaValidation(provider: DatabaseProvider, schema: DatabaseRuntimeSchema): DatabaseProvider;

package/dist/schema.js

@@ -0,0 +1,87 @@
+/** Built-in runtime adapter used by Zod-generated clients. */
+export const zodValidator = {
+    validate(schema, value) {
+        const result = schema.safeParse(value);
+        return result.success ? { success: true } : { success: false, issues: result.error.issues, cause: result.error };
+    }
+};
+export class SchemaDriftError extends Error {
+    layout;
+    recordId;
+    portal;
+    phase;
+    issues;
+    constructor(options, cause) {
+        const location = [options.layout, options.recordId && `record ${options.recordId}`, options.portal && `portal ${options.portal}`].filter(Boolean).join(', ');
+        super(`Schema drift detected in ${location}: ${options.issues.map(issue => `${issue.path.map(String).join('.')}: ${issue.message}`).join('; ')}`, { cause });
+        this.name = 'SchemaDriftError';
+        this.layout = options.layout;
+        this.recordId = options.recordId;
+        this.portal = options.portal;
+        this.phase = options.phase ?? (options.portal ? 'portal' : options.recordId ? 'record' : 'metadata');
+        this.issues = options.issues;
+    }
+}
+/** Decorates any provider with generated, provider-neutral metadata and result validation. */
+export function withSchemaValidation(provider, schema) {
+    return { name: provider.name, formatting: provider.formatting, async connect(context) {
+            const connection = await provider.connect(context);
+            return { formatting: connection.formatting, maxSessions: connection.maxSessions, close: connection.close?.bind(connection), async openSession(signal) {
+                    const session = await connection.openSession(signal);
+                    return { close: session.close.bind(session), fetchContainer: session.fetchContainer.bind(session), async execute(operation) {
+                            const result = await session.execute(operation);
+                            if (operation.type === 'layout.metadata')
+                                validateMetadata(schema, operation.layout, result);
+                            if (operation.type === 'record.get')
+                                validateRecord(schema, operation.layout, result);
+                            if (operation.type === 'record.list')
+                                for (const record of result)
+                                    validateRecord(schema, operation.layout, record);
+                            return result;
+                        } };
+                } };
+        } };
+}
+function validateRecord(schema, layout, record) {
+    const layoutSchema = schema.layouts[layout];
+    if (!layoutSchema)
+        return;
+    assertValid(schema.validator, layoutSchema.record, record, { layout, recordId: record.recordId, phase: 'record' });
+}
+function assertValid(validator, validationSchema, value, context) {
+    const result = validator.validate(validationSchema, value);
+    if (!result.success)
+        throw new SchemaDriftError({ ...context, issues: result.issues }, result.cause);
+}
+function validateMetadata(schema, layout, value) {
+    const expected = schema.layouts[layout]?.metadata;
+    if (!expected)
+        return;
+    const actual = value;
+    const issues = [];
+    compareFields(expected.fields, actual.fieldMetaData ?? [], ['fieldMetaData'], issues);
+    for (const [portal, fields] of Object.entries(expected.portals))
+        compareFields(fields, actual.portalMetaData?.[portal] ?? [], ['portalMetaData', portal], issues);
+    for (const portal of Object.keys(actual.portalMetaData ?? {}))
+        if (!(portal in expected.portals))
+            issues.push({ path: ['portalMetaData', portal], message: 'Unexpected portal' });
+    if (issues.length)
+        throw new SchemaDriftError({ layout, phase: 'metadata', issues });
+}
+function compareFields(expected, actualFields, path, issues) {
+    const actual = new Map(actualFields.map(field => [field.name, field]));
+    for (const [name, field] of Object.entries(expected)) {
+        const found = actual.get(name);
+        if (!found)
+            issues.push({ path: [...path, name], message: 'Missing field' });
+        else {
+            if (found.result !== field.result)
+                issues.push({ path: [...path, name, 'result'], message: `Expected ${field.result}, received ${found.result}` });
+            if (found.type !== field.type)
+                issues.push({ path: [...path, name, 'type'], message: `Expected ${field.type}, received ${found.type}` });
+        }
+    }
+    for (const name of actual.keys())
+        if (!(name in expected))
+            issues.push({ path: [...path, name], message: 'Unexpected field' });
+}

package/dist/typegen/dataApiSchemaSource.d.ts

@@ -0,0 +1,3 @@
+import { type DataApiProviderOptions } from '../connection/DataApiProvider.js';
+import type { SchemaSource } from './types.js';
+export declare function dataApiSchemaSource(options: DataApiProviderOptions): SchemaSource;

package/dist/typegen/dataApiSchemaSource.js

@@ -0,0 +1,32 @@
+import { Database } from '../connection/database.js';
+import { DataApiProvider } from '../connection/DataApiProvider.js';
+export function dataApiSchemaSource(options) {
+    return {
+        async introspect() {
+            const database = Database.create({ provider: new DataApiProvider(options) });
+            try {
+                const layouts = await database.listLayouts();
+                return {
+                    version: 1,
+                    layouts: await Promise.all(layouts.map(async (layout) => {
+                        const metadata = await layout.getLayoutMeta();
+                        return {
+                            name: layout.name,
+                            fields: unique(metadata.fieldMetaData.map(toField)),
+                            portals: Object.fromEntries(Object.entries(metadata.portalMetaData).map(([name, fields]) => [name, unique(fields.map(toField))]))
+                        };
+                    }))
+                };
+            }
+            finally {
+                await database.close();
+            }
+        }
+    };
+}
+function toField(field) {
+    return { name: field.name, result: field.result, type: field.type, writable: field.type === 'normal', required: field.notEmpty };
+}
+function unique(fields) {
+    return [...new Map(fields.map(field => [field.name, field])).values()];
+}

package/dist/typegen/dependencies.d.ts

@@ -0,0 +1,11 @@
+type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun';
+export interface InstallPlan {
+    cwd: string;
+    command: PackageManager;
+    args: string[];
+}
+/** Ensures generated code can resolve its direct `zod` import. */
+export declare function ensureZodInstalled(start: string): Promise<boolean>;
+/** Returns null when Zod is already declared. Exported for alternate CLIs. */
+export declare function getZodInstallPlan(start: string): Promise<InstallPlan | null>;
+export {};