@jd-data-limited/easy-fm 5.0.0-beta.4 → 5.0.0-beta.7

package/dist/bin/cli.js

@@ -40,7 +40,10 @@ program
     if (await typegen.ensureZodInstalled(dirname(configPath)))
         console.log(chalk.green('Installed Zod for generated runtime validation.'));
     const loaded = await import(pathToFileURL(configPath).href);
-    const result = await typegen.generate(loaded.default);
+    const result = await typegen.generate({ ...loaded.default, onDiagnostic: (diagnostic) => {
+            const location = [diagnostic.database, diagnostic.layout, diagnostic.portal].filter(Boolean).join('/');
+            console.warn(chalk.yellow(`Warning [${location}]: ${diagnostic.message}`));
+        } });
     console.log(chalk.green(`Generated ${result.layouts} layouts in ${result.output}`));
 });
 program.parse(process.argv);

package/dist/bin/init.d.ts

@@ -2,5 +2,4 @@ export { configExists } from '../typegen/init.js';
 export interface InitOptions {
     config: string;
 }
-/** Interactive initializer shared by `easyfm init` and first `easyfm typegen`. */
 export declare function initializeTypegen({ config }: InitOptions): Promise<boolean>;

package/dist/bin/init.js

@@ -1,9 +1,8 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { dirname, resolve } from 'node:path';
-import { configExists, readEnvironment, writeDataApiInitialization } from '../typegen/init.js';
+import { configExists, writeMultiDatabaseInitialization } from '../typegen/init.js';
 export { configExists } from '../typegen/init.js';
-/** Interactive initializer shared by `easyfm init` and first `easyfm typegen`. */
 export async function initializeTypegen({ config }) {
     const configPath = resolve(config);
     if (await configExists(configPath)) {
@@ -11,36 +10,34 @@ export async function initializeTypegen({ config }) {
         return false;
     }
     console.log(chalk.bold.cyan('EasyFM typegen setup'));
-    const envPath = resolve(dirname(configPath), '.env');
-    const existingEnvironment = await readEnvironment(envPath);
-    const answers = await inquirer.prompt([
-        { type: 'select', name: 'provider', message: 'Provider', choices: [{ name: 'Data API/OData', value: 'data-api/odata' }] },
-        { type: 'select', name: 'transports', message: 'Transports', default: 'both', choices: [
-                { name: 'Both', value: 'both' },
-                { name: 'Data API', value: 'data-api' },
-                { name: 'OData', value: 'odata' }
-            ] },
-        { type: 'input', name: 'hostname', message: 'FileMaker host URL', default: existingEnvironment.FM_HOST ?? 'https://', validate: validHost },
-        { type: 'input', name: 'database', message: 'Database filename', default: existingEnvironment.FM_DATABASE, validate: required('Database filename') },
-        { type: 'input', name: 'username', message: 'Username', default: existingEnvironment.FM_USERNAME, validate: required('Username') },
-        { type: 'password', name: 'password', message: existingEnvironment.FM_PASSWORD ? 'Password (leave blank to keep existing)' : 'Password', mask: '*', validate: value => existingEnvironment.FM_PASSWORD || value ? true : 'Password is required' },
-        { type: 'input', name: 'output', message: 'Generated client directory', default: './src/easyfm-generated', validate: required('Output directory') }
-    ]);
-    if (!answers.password)
-        answers.password = existingEnvironment.FM_PASSWORD ?? '';
-    await writeDataApiInitialization(configPath, answers);
+    const { output } = await inquirer.prompt([{ type: 'input', name: 'output', message: 'Generated client directory', default: './src/easyfm-generated', validate: required('Output directory') }]);
+    const databases = [];
+    let more = true;
+    while (more) {
+        const answers = await inquirer.prompt([
+            { type: 'input', name: 'key', message: 'Database client name', validate: (value) => !value.trim() ? 'Client name is required' : databases.some(db => db.key === value) ? 'Client name must be unique' : true },
+            { type: 'select', name: 'provider', message: 'Provider', choices: [{ name: 'Data API/OData', value: 'data-api/odata' }] },
+            { type: 'select', name: 'transports', message: 'Transports', default: 'both', choices: [{ name: 'Both', value: 'both' }, { name: 'Data API', value: 'data-api' }, { name: 'OData', value: 'odata' }] },
+            { type: 'input', name: 'hostname', message: 'FileMaker host URL', default: 'https://', validate: validHost },
+            { type: 'input', name: 'database', message: 'Database filename', validate: required('Database filename') },
+            { type: 'input', name: 'username', message: 'Username', validate: required('Username') },
+            { type: 'password', name: 'password', message: 'Password', mask: '*', validate: required('Password') }
+        ]);
+        databases.push(answers);
+        const result = await inquirer.prompt([{ type: 'confirm', name: 'more', message: 'Add another database?', default: false }]);
+        more = result.more;
+    }
+    await writeMultiDatabaseInitialization(configPath, { output, databases });
     console.log(chalk.green(`Created ${configPath}`));
-    console.log(chalk.green(`Saved Data API credentials in ${envPath}`));
+    console.log(chalk.green(`Saved database-scoped credentials in ${resolve(dirname(configPath), '.env')}`));
     console.log(chalk.dim('Keep .env out of version control.'));
     return true;
 }
 function required(label) { return (value) => value.trim() ? true : `${label} is required`; }
-function validHost(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'http:' || url.protocol === 'https:' ? true : 'Use an http:// or https:// URL';
-    }
-    catch {
-        return 'Use a valid http:// or https:// URL';
-    }
+function validHost(value) { try {
+    const url = new URL(value);
+    return url.protocol === 'http:' || url.protocol === 'https:' ? true : 'Use an http:// or https:// URL';
 }
+catch {
+    return 'Use a valid http:// or https:// URL';
+} }

package/dist/layouts/layout.js

@@ -3,7 +3,7 @@
  */
 import { LayoutRecordManager } from './layoutRecordManager.js';
 import { FMError } from '../FMError.js';
-import { ApiLayoutMetadata } from '../models/apiResults.js';
+import { ApiLayoutMetadata, stripInaccessibleMetadata } from '../models/apiResults.js';
 export class Layout {
     database;
     name;
@@ -37,7 +37,7 @@ export class Layout {
             return this.metadata;
         }
         const { value: res } = await this.database.execute({ type: 'layout.metadata', layout: this.name });
-        this.metadata = ApiLayoutMetadata.parse(res);
+        this.metadata = stripInaccessibleMetadata(ApiLayoutMetadata.parse(res));
         return this.metadata;
     }
 }

package/dist/models/apiResults.d.ts

@@ -7,6 +7,7 @@ export declare const ApiFieldTypes: {
 export declare const ApiFieldDisplayTypes: {
     readonly EDIT_TEXT: "editText";
     readonly POPUP_LIST: "popupList";
+    readonly POPUP_MENU: "popupMenu";
     readonly CHECKBOX: "checkBox";
     readonly RADIO_BUTTONS: "radioButtons";
     readonly SELECTION_LIST: "selectionList";
@@ -39,28 +40,29 @@ export declare const ApiLayout: z.ZodType<{
 }>;
 export declare const ApiFieldMetadata: z.ZodObject<{
     name: z.ZodString;
-    type: z.ZodEnum<{
+    type: z.ZodUnion<readonly [z.ZodEnum<{
         readonly NORMAL: "normal";
         readonly CALCULATION: "calculation";
         readonly SUMMARY: "summary";
-    }>;
+    }>, z.ZodLiteral<"invalid">]>;
     displayType: z.ZodEnum<{
         readonly EDIT_TEXT: "editText";
         readonly POPUP_LIST: "popupList";
+        readonly POPUP_MENU: "popupMenu";
         readonly CHECKBOX: "checkBox";
         readonly RADIO_BUTTONS: "radioButtons";
         readonly SELECTION_LIST: "selectionList";
         readonly CALENDAR: "calendar";
         readonly SECURE_TEXT: "secureText";
     }>;
-    result: z.ZodEnum<{
+    result: z.ZodUnion<readonly [z.ZodEnum<{
         readonly TEXT: "text";
         readonly NUMBER: "number";
         readonly DATE: "date";
         readonly TIME: "time";
         readonly TIMESTAMP: "timeStamp";
         readonly CONTAINER: "container";
-    }>;
+    }>, z.ZodLiteral<"invalid">]>;
     global: z.ZodBoolean;
     autoEnter: z.ZodBoolean;
     fourDigitYear: z.ZodBoolean;
@@ -78,34 +80,35 @@ export declare const ApiValueList: z.ZodObject<{
     type: z.ZodString;
     values: z.ZodArray<z.ZodObject<{
         value: z.ZodString;
-        displayName: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const ApiLayoutMetadata: z.ZodObject<{
     fieldMetaData: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        type: z.ZodEnum<{
+        type: z.ZodUnion<readonly [z.ZodEnum<{
             readonly NORMAL: "normal";
             readonly CALCULATION: "calculation";
             readonly SUMMARY: "summary";
-        }>;
+        }>, z.ZodLiteral<"invalid">]>;
         displayType: z.ZodEnum<{
             readonly EDIT_TEXT: "editText";
             readonly POPUP_LIST: "popupList";
+            readonly POPUP_MENU: "popupMenu";
             readonly CHECKBOX: "checkBox";
             readonly RADIO_BUTTONS: "radioButtons";
             readonly SELECTION_LIST: "selectionList";
             readonly CALENDAR: "calendar";
             readonly SECURE_TEXT: "secureText";
         }>;
-        result: z.ZodEnum<{
+        result: z.ZodUnion<readonly [z.ZodEnum<{
             readonly TEXT: "text";
             readonly NUMBER: "number";
             readonly DATE: "date";
             readonly TIME: "time";
             readonly TIMESTAMP: "timeStamp";
             readonly CONTAINER: "container";
-        }>;
+        }>, z.ZodLiteral<"invalid">]>;
         global: z.ZodBoolean;
         autoEnter: z.ZodBoolean;
         fourDigitYear: z.ZodBoolean;
@@ -120,28 +123,29 @@ export declare const ApiLayoutMetadata: z.ZodObject<{
     }, z.core.$strip>>;
     portalMetaData: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        type: z.ZodEnum<{
+        type: z.ZodUnion<readonly [z.ZodEnum<{
             readonly NORMAL: "normal";
             readonly CALCULATION: "calculation";
             readonly SUMMARY: "summary";
-        }>;
+        }>, z.ZodLiteral<"invalid">]>;
         displayType: z.ZodEnum<{
             readonly EDIT_TEXT: "editText";
             readonly POPUP_LIST: "popupList";
+            readonly POPUP_MENU: "popupMenu";
             readonly CHECKBOX: "checkBox";
             readonly RADIO_BUTTONS: "radioButtons";
             readonly SELECTION_LIST: "selectionList";
             readonly CALENDAR: "calendar";
             readonly SECURE_TEXT: "secureText";
         }>;
-        result: z.ZodEnum<{
+        result: z.ZodUnion<readonly [z.ZodEnum<{
             readonly TEXT: "text";
             readonly NUMBER: "number";
             readonly DATE: "date";
             readonly TIME: "time";
             readonly TIMESTAMP: "timeStamp";
             readonly CONTAINER: "container";
-        }>;
+        }>, z.ZodLiteral<"invalid">]>;
         global: z.ZodBoolean;
         autoEnter: z.ZodBoolean;
         fourDigitYear: z.ZodBoolean;
@@ -159,10 +163,19 @@ export declare const ApiLayoutMetadata: z.ZodObject<{
         type: z.ZodString;
         values: z.ZodArray<z.ZodObject<{
             value: z.ZodString;
-            displayName: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+export type ApiLayoutMetadataValue = z.infer<typeof ApiLayoutMetadata>;
+export declare function isAccessibleFieldMetadata(field: z.infer<typeof ApiFieldMetadata>): field is z.infer<typeof ApiFieldMetadata> & {
+    type: z.infer<typeof ApiFieldTypes>;
+    result: z.infer<typeof ApiFieldResultTypes>;
+};
+/** Removes FileMaker metadata placeholders for fields unavailable to the current account. */
+export declare function stripInaccessibleMetadata(metadata: ApiLayoutMetadataValue): ApiLayoutMetadataValue;
+/** Removes inaccessible placeholder values before strict generated validation. */
+export declare function stripInaccessibleFieldData<T extends Record<string, unknown>>(fields: T): T;
 export declare const ApiScriptResult: z.ZodObject<{
     scriptError: z.ZodString;
     scriptResult: z.ZodOptional<z.ZodString>;

package/dist/models/apiResults.js

@@ -10,6 +10,7 @@ export const ApiFieldTypes = {
 export const ApiFieldDisplayTypes = {
     EDIT_TEXT: 'editText',
     POPUP_LIST: 'popupList',
+    POPUP_MENU: 'popupMenu',
     CHECKBOX: 'checkBox',
     RADIO_BUTTONS: 'radioButtons',
     SELECTION_LIST: 'selectionList',
@@ -38,9 +39,9 @@ export const ApiLayout = z.lazy(() => z.object({
 }));
 export const ApiFieldMetadata = z.object({
     name: z.string(),
-    type: z.enum(ApiFieldTypes),
+    type: z.union([z.enum(ApiFieldTypes), z.literal('invalid')]),
     displayType: z.enum(ApiFieldDisplayTypes),
-    result: z.enum(ApiFieldResultTypes),
+    result: z.union([z.enum(ApiFieldResultTypes), z.literal('invalid')]),
     global: z.boolean(),
     autoEnter: z.boolean(),
     fourDigitYear: z.boolean(),
@@ -58,7 +59,7 @@ export const ApiValueList = z.object({
     type: z.string(),
     values: z.array(z.object({
         value: z.string(),
-        displayName: z.string()
+        displayName: z.string().optional()
     }))
 });
 export const ApiLayoutMetadata = z.object({
@@ -66,6 +67,25 @@ export const ApiLayoutMetadata = z.object({
     portalMetaData: z.record(z.string(), z.array(ApiFieldMetadata)),
     valueLists: z.array(ApiValueList).optional()
 });
+export function isAccessibleFieldMetadata(field) {
+    return field.type !== 'invalid' && field.result !== 'invalid' && field.name !== '<No Access>';
+}
+/** Removes FileMaker metadata placeholders for fields unavailable to the current account. */
+export function stripInaccessibleMetadata(metadata) {
+    return {
+        ...metadata,
+        fieldMetaData: metadata.fieldMetaData.filter(isAccessibleFieldMetadata),
+        portalMetaData: Object.fromEntries(Object.entries(metadata.portalMetaData).map(([name, fields]) => [name, fields.filter(isAccessibleFieldMetadata)]))
+    };
+}
+/** Removes inaccessible placeholder values before strict generated validation. */
+export function stripInaccessibleFieldData(fields) {
+    if (!Object.hasOwn(fields, '<No Access>'))
+        return fields;
+    const result = { ...fields };
+    delete result['<No Access>'];
+    return result;
+}
 export const ApiScriptResult = z.object({
     scriptError: z.string(),
     scriptResult: z.string().optional()

package/dist/records/recordBase.js

@@ -3,6 +3,7 @@
  */
 import { EventEmitter } from 'node:events';
 import { RecordTypes } from '../types.js';
+import { stripInaccessibleFieldData } from '../models/apiResults.js';
 import { DateField, NumberField, TextField, TimeField, TimeStampField, ValueFieldBase } from "./fields/valueField.js";
 import { ContainerField } from "./fields/containerField.js";
 export class RecordBase extends EventEmitter {
@@ -41,7 +42,7 @@ export class RecordBase extends EventEmitter {
     }
     processFieldData(fieldData) {
         const fields = {};
-        for (const [key, value] of Object.entries(fieldData)) {
+        for (const [key, value] of Object.entries(stripInaccessibleFieldData(fieldData))) {
             const fieldMeta = this.getFieldMetadata(key);
             let field;
             switch (fieldMeta.result) {

package/dist/schema.js

@@ -1,3 +1,4 @@
+import { stripInaccessibleFieldData, stripInaccessibleMetadata } from './models/apiResults.js';
 /** Built-in runtime adapter used by Zod-generated clients. */
 export const zodValidator = {
     validate(schema, value) {
@@ -29,19 +30,28 @@ export function withSchemaValidation(provider, schema) {
             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')
+                            let result = await session.execute(operation);
+                            if (operation.type === 'layout.metadata') {
+                                result = stripInaccessibleMetadata(result);
                                 validateMetadata(schema, operation.layout, result);
-                            if (operation.type === 'record.get')
+                            }
+                            if (operation.type === 'record.get') {
+                                result = stripRecord(result);
                                 validateRecord(schema, operation.layout, result);
-                            if (operation.type === 'record.list')
+                            }
+                            if (operation.type === 'record.list') {
+                                result = result.map(stripRecord);
                                 for (const record of result)
                                     validateRecord(schema, operation.layout, record);
+                            }
                             return result;
                         } };
                 } };
         } };
 }
+function stripRecord(record) {
+    return { ...record, fieldData: stripInaccessibleFieldData(record.fieldData), portalData: record.portalData && Object.fromEntries(Object.entries(record.portalData).map(([name, rows]) => [name, rows.map(row => stripInaccessibleFieldData(row))])) };
+}
 function validateRecord(schema, layout, record) {
     const layoutSchema = schema.layouts[layout];
     if (!layoutSchema)

package/dist/typegen/dataApiSchemaSource.js

@@ -1,22 +1,26 @@
 import { Database } from '../connection/database.js';
 import { DataApiProvider } from '../connection/DataApiProvider.js';
+import { ApiLayoutMetadata, isAccessibleFieldMetadata } from '../models/apiResults.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))]))
-                        };
-                    }))
-                };
+                const inspected = await Promise.all(layouts.map(async (layout) => {
+                    // Read raw metadata here so inaccessible placeholders can produce diagnostics before stripping.
+                    const { value } = await database.execute({ type: 'layout.metadata', layout: layout.name });
+                    const metadata = ApiLayoutMetadata.parse(value);
+                    const diagnostics = metadata.fieldMetaData.filter(isInaccessible).map(field => ({ level: 'warning', layout: layout.name, message: `Field ${JSON.stringify(field.name)} is inaccessible and was excluded from generated types. Check this account's field privileges.` }));
+                    for (const [portal, fields] of Object.entries(metadata.portalMetaData))
+                        for (const field of fields.filter(isInaccessible))
+                            diagnostics.push({ level: 'warning', layout: layout.name, portal, message: `Portal field ${JSON.stringify(field.name)} is inaccessible and was excluded from generated types. Check this account's field privileges.` });
+                    return {
+                        layout: { name: layout.name, fields: unique(metadata.fieldMetaData.filter(isAccessibleFieldMetadata).map(toField)), portals: Object.fromEntries(Object.entries(metadata.portalMetaData).map(([name, fields]) => [name, unique(fields.filter(isAccessibleFieldMetadata).map(toField))])) },
+                        diagnostics
+                    };
+                }));
+                return { version: 1, layouts: inspected.map(item => item.layout), diagnostics: inspected.flatMap(item => item.diagnostics) };
             }
             finally {
                 await database.close();
@@ -24,7 +28,10 @@ export function dataApiSchemaSource(options) {
         }
     };
 }
+function isInaccessible(field) { return field.type === 'invalid' || field.result === 'invalid' || field.name === '<No Access>'; }
 function toField(field) {
+    if (!isAccessibleFieldMetadata(field))
+        throw new Error('Cannot generate an inaccessible field');
     return { name: field.name, result: field.result, type: field.type, writable: field.type === 'normal', required: field.notEmpty };
 }
 function unique(fields) {

package/dist/typegen/generate.d.ts

@@ -2,4 +2,8 @@ import type { TypegenConfig } from './types.js';
 export declare function generate(config: TypegenConfig): Promise<{
     output: string;
     layouts: number;
+    databases: number;
+    diagnostics: Array<import('./types.js').TypegenDiagnostic & {
+        database: string;
+    }>;
 }>;

package/dist/typegen/generate.js

@@ -2,84 +2,63 @@ import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import { zodTypegenValidator } from './zod.js';
 export async function generate(config) {
-    const discovered = await config.source.introspect();
-    const selected = config.layouts ? discovered.layouts.filter(layout => config.layouts.includes(layout.name)) : discovered.layouts;
-    const missing = config.layouts?.filter(name => !selected.some(layout => layout.name === name)) ?? [];
-    if (missing.length)
-        throw new Error(`Layouts not found: ${missing.join(', ')}`);
-    const schema = { version: 1, layouts: [...selected].sort((a, b) => a.name.localeCompare(b.name)) };
+    const diagnostics = [];
+    const databases = await Promise.all(databaseEntries(config).map(async ([key, databaseConfig]) => {
+        const discovered = await databaseConfig.source.introspect();
+        for (const diagnostic of discovered.diagnostics ?? []) {
+            const item = { ...diagnostic, database: key };
+            diagnostics.push(item);
+            (config.onDiagnostic ?? defaultDiagnosticReporter)(item);
+        }
+        const selected = databaseConfig.layouts ? discovered.layouts.filter(layout => databaseConfig.layouts.includes(layout.name)) : discovered.layouts;
+        const missing = databaseConfig.layouts?.filter(name => !selected.some(layout => layout.name === name)) ?? [];
+        if (missing.length)
+            throw new Error(`Layouts not found in database ${key}: ${missing.join(', ')}`);
+        return { key, config: databaseConfig, schema: { version: 1, layouts: [...selected].sort((a, b) => a.name.localeCompare(b.name)) }, validator: databaseConfig.validator ?? config.validator ?? zodTypegenValidator() };
+    }));
     const output = resolve(config.output);
     const temporary = `${output}.tmp-${process.pid}`;
     await rm(temporary, { recursive: true, force: true });
     await mkdir(temporary, { recursive: true });
-    await writeFile(resolve(temporary, 'client.ts'), renderClient(schema, config.validator ?? zodTypegenValidator()), 'utf8');
-    await writeFile(resolve(temporary, 'schema.json'), `${JSON.stringify({ ...schema, transports: config.transports ?? ['data-api', 'odata'] }, null, 2)}\n`, 'utf8');
+    await writeFile(resolve(temporary, 'client.ts'), renderClient(databases), 'utf8');
+    const manifest = { version: 1, databases: Object.fromEntries(databases.map(db => [db.key, { ...db.schema, provider: db.config.provider, transports: db.config.transports ?? ['data-api', 'odata'] }])) };
+    await writeFile(resolve(temporary, 'schema.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     await mkdir(dirname(output), { recursive: true });
     await rm(output, { recursive: true, force: true });
     await rename(temporary, output);
-    return { output, layouts: schema.layouts.length };
+    return { output, databases: databases.length, layouts: databases.reduce((sum, db) => sum + db.schema.layouts.length, 0), diagnostics };
 }
-function renderClient(schema, validator) {
-    const interfaces = schema.layouts.map(renderLayout).join('\n\n');
-    const structure = schema.layouts.map(layout => `${quote(layout.name)}: ${layoutTypeName(layout)}`).join(',\n        ');
-    const validators = schema.layouts.map(layout => `${quote(layout.name)}: {\n        record: ${validator.renderRecord(layout)},\n        metadata: ${renderMetadata(layout)}\n    }`).join(',\n    ');
-    const properties = schema.layouts.map(layout => `${safeProperty(layout.clientName ?? layout.name)}: database.layout<${layoutTypeName(layout)}>(${quote(layout.name)})`).join(',\n        ');
+function defaultDiagnosticReporter(diagnostic) { console.warn(`[easyfm:typegen] warning [${diagnostic.database}${diagnostic.layout ? `/${diagnostic.layout}` : ''}${diagnostic.portal ? `/${diagnostic.portal}` : ''}]: ${diagnostic.message}`); }
+function databaseEntries(config) {
+    if (config.databases && Object.keys(config.databases).length)
+        return Object.entries(config.databases);
+    if (!config.source)
+        throw new Error('Typegen config requires source or databases');
+    return [['database', { source: config.source, transports: config.transports, layouts: config.layouts, validator: config.validator }]];
+}
+function renderClient(databases) {
+    const imports = [...new Set(databases.flatMap(db => db.validator.imports))].join('\n');
+    const interfaces = databases.flatMap(db => db.schema.layouts.map(layout => renderLayout(db.key, layout))).join('\n\n');
+    const structures = databases.map(db => `export interface ${databaseType(db.key)} extends DatabaseStructure {\n    layouts: {${db.schema.layouts.map(layout => `${quote(layout.name)}: ${layoutTypeName(db.key, layout)}`).join(',')}}\n}`).join('\n\n');
+    const schemas = databases.map(db => `${prop(db.key)}: {validator: ${db.validator.runtimeValidator}, layouts: {${db.schema.layouts.map(layout => `${quote(layout.name)}: {record: ${db.validator.renderRecord(layout)}, metadata: ${renderMetadata(layout)}}`).join(',')}}}`).join(',');
+    const factories = databases.map(db => `function create${typeId(db.key, 'Database')}Client (provider: DatabaseProvider) {\n    const database = Database.create<${databaseType(db.key)}>({provider: withSchemaValidation(provider, easyFMSchemas.${prop(db.key)})})\n    return {database, ${db.schema.layouts.map(layout => `${prop(layout.clientName ?? layout.name)}: database.layout<${layoutTypeName(db.key, layout)}>(${quote(layout.name)})`).join(',')}}\n}`).join('\n\n');
     return `/* Generated by easyfm typegen. Do not edit. */
-import {Database, withSchemaValidation, ${validator.runtimeValidator}, type DatabaseProvider, type DatabaseStructure, type LayoutInterface, type Portal, type ReadonlyField, type TextField, type NumberField, type DateField, type TimeField, type TimeStampField, type ContainerField} from '@jd-data-limited/easy-fm'
-${validator.imports.join('\n')}
-
+import {Database, withSchemaValidation, zodValidator, type DatabaseProvider, type DatabaseStructure, type LayoutInterface, type Portal, type ReadonlyField, type TextField, type NumberField, type DateField, type TimeField, type TimeStampField, type ContainerField} from '@jd-data-limited/easy-fm'
+${imports}
 ${interfaces}
-
-export interface GeneratedDatabase extends DatabaseStructure {
-    layouts: {
-        ${structure}
-    }
-}
-
-export const easyFMSchema = {
-    validator: ${validator.runtimeValidator},
-    layouts: {
-        ${validators}
-    }
-} satisfies Parameters<typeof withSchemaValidation>[1]
-
-export function createEasyFMClient (provider: DatabaseProvider) {
-    const database = Database.create<GeneratedDatabase>({provider: withSchemaValidation(provider, easyFMSchema)})
-    return {
-        database,
-        ${properties}
-    }
-}
+${structures}
+export const easyFMSchemas = {${schemas}}
+${factories}
+export function createEasyFMClient (providers: {${databases.map(db => `${prop(db.key)}: DatabaseProvider`).join(',')}}) { return {${databases.map(db => `${prop(db.key)}: create${typeId(db.key, 'Database')}Client(providers.${prop(db.key)})`).join(',')}} }
 `;
 }
-function renderLayout(layout) {
-    const fields = layout.fields.map(field => `${quote(field.name)}: ${fieldType(field)}`).join('\n        ');
-    const portals = Object.entries(layout.portals).map(([name, portalFields]) => `${quote(name)}: Portal<{\n            ${portalFields.map(field => `${quote(field.name)}: ${fieldType(field)}`).join('\n            ')}\n        }>`).join('\n        ');
-    return `export interface ${layoutTypeName(layout)} extends LayoutInterface {
-    fields: {
-        ${fields}
-    }
-    portals: {
-        ${portals}
-    }
-}`;
-}
-function fieldType(field) {
-    const type = { text: 'TextField', number: 'NumberField', date: 'DateField', time: 'TimeField', timeStamp: 'TimeStampField', container: 'ContainerField' }[field.result];
-    return field.writable ? type : `ReadonlyField<${type}>`;
-}
-function renderMetadata(layout) {
-    const fields = renderMetadataFields(layout.fields);
-    const portals = Object.entries(layout.portals).map(([name, portalFields]) => `${quote(name)}: ${renderMetadataFields(portalFields)}`).join(', ');
-    return `{fields: ${fields}, portals: {${portals}}}`;
-}
-function renderMetadataFields(fields) {
-    return `{${fields.map(field => `${quote(field.name)}: {result: ${quote(field.result)}, type: ${quote(field.type)}}`).join(', ')}}`;
-}
-function layoutTypeName(layout) { return `${identifier(layout.clientName ?? layout.name, 'Layout')}Layout`; }
-function safeProperty(value) { return identifier(value, 'layout'); }
-function identifier(value, fallback) {
-    const cleaned = value.replace(/[^a-zA-Z0-9_$]/g, '_').replace(/^[^a-zA-Z_$]+/, '');
-    return cleaned || fallback;
-}
+function renderLayout(db, layout) { return `export interface ${layoutTypeName(db, layout)} extends LayoutInterface { fields: {${layout.fields.map(f => `${quote(f.name)}: ${fieldType(f)}`).join(',')}}; portals: {${Object.entries(layout.portals).map(([name, fields]) => `${quote(name)}: Portal<{${fields.map(f => `${quote(f.name)}: ${fieldType(f)}`).join(',')}}>`).join(',')}} }`; }
+function fieldType(f) { const t = { text: 'TextField', number: 'NumberField', date: 'DateField', time: 'TimeField', timeStamp: 'TimeStampField', container: 'ContainerField' }[f.result]; return f.writable ? t : `ReadonlyField<${t}>`; }
+function renderMetadata(layout) { return `{fields: ${metadataFields(layout.fields)}, portals: {${Object.entries(layout.portals).map(([name, fields]) => `${quote(name)}: ${metadataFields(fields)}`).join(',')}}}`; }
+function metadataFields(fields) { return `{${fields.map(f => `${quote(f.name)}: {result: ${quote(f.result)}, type: ${quote(f.type)}}`).join(',')}}`; }
+function databaseType(db) { return `${typeId(db, 'Database')}Database`; }
+function layoutTypeName(db, layout) { return `${typeId(db, 'Database')}${typeId(layout.clientName ?? layout.name, 'Layout')}Layout`; }
+function prop(value) { return id(value, 'item'); }
+function typeId(value, fallback) { const valueId = id(value, fallback); return valueId[0].toUpperCase() + valueId.slice(1); }
+function id(value, fallback) { const clean = value.replace(/[^a-zA-Z0-9_$]/g, '_').replace(/^[^a-zA-Z_$]+/, ''); return clean || fallback; }
 function quote(value) { return JSON.stringify(value); }

package/dist/typegen/index.d.ts

@@ -1,6 +1,6 @@
 export { generate } from './generate.js';
 export { dataApiSchemaSource } from './dataApiSchemaSource.js';
 export { zodTypegenValidator } from './zod.js';
-export { configExists, readEnvironment, writeDataApiInitialization, type DataApiInitAnswers } from './init.js';
+export { configExists, readEnvironment, writeDataApiInitialization, writeMultiDatabaseInitialization, type DataApiInitAnswers, type MultiDatabaseInitAnswers } from './init.js';
 export { ensureZodInstalled, getZodInstallPlan, type InstallPlan } from './dependencies.js';
-export { defineTypegenConfig, type SchemaSource, type TypegenConfig, type TypegenField, type TypegenLayout, type TypegenSchema, type TypegenTransport, type TypegenValidator } from './types.js';
+export { defineTypegenConfig, type SchemaSource, type TypegenConfig, type TypegenDatabaseConfig, type TypegenDiagnostic, type TypegenField, type TypegenLayout, type TypegenSchema, type TypegenTransport, type TypegenValidator } from './types.js';

package/dist/typegen/index.js

@@ -1,6 +1,6 @@
 export { generate } from './generate.js';
 export { dataApiSchemaSource } from './dataApiSchemaSource.js';
 export { zodTypegenValidator } from './zod.js';
-export { configExists, readEnvironment, writeDataApiInitialization } from './init.js';
+export { configExists, readEnvironment, writeDataApiInitialization, writeMultiDatabaseInitialization } from './init.js';
 export { ensureZodInstalled, getZodInstallPlan } from './dependencies.js';
 export { defineTypegenConfig } from './types.js';

package/dist/typegen/init.d.ts

@@ -7,7 +7,14 @@ export interface DataApiInitAnswers {
     password: string;
     output: string;
 }
+export interface MultiDatabaseInitAnswers {
+    output: string;
+    databases: Array<DataApiInitAnswers & {
+        key: string;
+    }>;
+}
 export declare function configExists(path: string): Promise<boolean>;
 /** Non-interactive write step, usable by alternate setup UIs. */
 export declare function writeDataApiInitialization(config: string, answers: DataApiInitAnswers): Promise<void>;
+export declare function writeMultiDatabaseInitialization(config: string, answers: MultiDatabaseInitAnswers): Promise<void>;
 export declare function readEnvironment(path: string): Promise<Record<string, string>>;

package/dist/typegen/init.js

@@ -27,6 +27,25 @@ export async function writeDataApiInitialization(config, answers) {
     await updateEnvironment(envPath, { FM_HOST: answers.hostname, FM_DATABASE: answers.database, FM_USERNAME: answers.username, FM_PASSWORD: answers.password });
     await ensureEnvironmentIgnored(directory);
 }
+export async function writeMultiDatabaseInitialization(config, answers) {
+    const configPath = resolve(config);
+    const directory = dirname(configPath);
+    await mkdir(directory, { recursive: true });
+    const file = await open(configPath, 'wx');
+    try {
+        await file.writeFile(renderMultiConfig(answers), 'utf8');
+    }
+    finally {
+        await file.close();
+    }
+    const environment = {};
+    for (const db of answers.databases) {
+        const prefix = envPrefix(db.key);
+        Object.assign(environment, { [`${prefix}_HOST`]: db.hostname, [`${prefix}_DATABASE`]: db.database, [`${prefix}_USERNAME`]: db.username, [`${prefix}_PASSWORD`]: db.password });
+    }
+    await updateEnvironment(resolve(directory, '.env'), environment);
+    await ensureEnvironmentIgnored(directory);
+}
 export async function readEnvironment(path) {
     try {
         const contents = await readFile(path, 'utf8');
@@ -60,6 +79,15 @@ export default defineTypegenConfig({
 })
 `;
 }
+function renderMultiConfig(answers) {
+    const databases = answers.databases.map(db => {
+        const prefix = envPrefix(db.key);
+        const transports = db.transports === 'both' ? ['data-api', 'odata'] : [db.transports];
+        return `${JSON.stringify(db.key)}: {provider: 'data-api/odata', transports: ${JSON.stringify(transports)}, source: dataApiSchemaSource({hostname: required('${prefix}_HOST'), database: required('${prefix}_DATABASE'), credentials: {method: 'filemaker', username: required('${prefix}_USERNAME'), password: required('${prefix}_PASSWORD')}, externalSources: []})}`;
+    }).join(',\n        ');
+    return `import {dataApiSchemaSource, defineTypegenConfig, zodTypegenValidator} from '@jd-data-limited/easy-fm/typegen'\n\nfunction required(name) { const value = process.env[name]; if (!value) throw new Error(\`Missing required environment variable \${name}\`); return value }\n\nexport default defineTypegenConfig({output: ${JSON.stringify(answers.output)}, validator: zodTypegenValidator(), databases: {\n        ${databases}\n    }})\n`;
+}
+function envPrefix(key) { return `FM_${key.replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}`; }
 async function updateEnvironment(path, values) {
     let contents = '';
     try {

package/dist/typegen/types.d.ts

@@ -12,9 +12,16 @@ export interface TypegenLayout {
     fields: TypegenField[];
     portals: Record<string, TypegenField[]>;
 }
+export interface TypegenDiagnostic {
+    level: 'warning';
+    message: string;
+    layout?: string;
+    portal?: string;
+}
 export interface TypegenSchema {
     version: 1;
     layouts: TypegenLayout[];
+    diagnostics?: TypegenDiagnostic[];
 }
 export type TypegenTransport = 'data-api' | 'odata';
 export interface SchemaSource {
@@ -28,13 +35,25 @@ export interface TypegenValidator {
     renderRecord(layout: TypegenLayout): string;
 }
 export interface TypegenConfig {
-    source: SchemaSource;
     output: string;
+    /** Single-database shorthand. */
+    source?: SchemaSource;
     /** Placeholder describing intended runtime transports. */
     transports?: TypegenTransport[];
     /** Restrict output to these FileMaker layout names. */
     layouts?: string[];
     /** Defaults to the built-in strict Zod validator. */
     validator?: TypegenValidator;
+    databases?: Record<string, TypegenDatabaseConfig>;
+    onDiagnostic?: (diagnostic: TypegenDiagnostic & {
+        database: string;
+    }) => void;
+}
+export interface TypegenDatabaseConfig {
+    source: SchemaSource;
+    provider?: string;
+    transports?: TypegenTransport[];
+    layouts?: string[];
+    validator?: TypegenValidator;
 }
 export declare function defineTypegenConfig(config: TypegenConfig): TypegenConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.7",
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^15.0.0",