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

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/typegen/generate.d.ts

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

package/dist/typegen/generate.js

@@ -2,84 +2,56 @@ 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 databases = await Promise.all(databaseEntries(config).map(async ([key, databaseConfig]) => {
+        const discovered = await databaseConfig.source.introspect();
+        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 };
-}
-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        ');
+    return { output, databases: databases.length, layouts: databases.reduce((sum, db) => sum + db.schema.layouts.length, 0) };
+}
+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 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

@@ -28,13 +28,22 @@ 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>;
+}
+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.5",
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^15.0.0",