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

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 RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
-import { type ApiFieldData } from '../models/apiResults.js';
-import { Field, type FieldValue } from './field.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,15 +19,17 @@ 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
      *
      * @returns {boolean} A boolean value indicating whether any of the fields have been edited.
      */
     get edited(): boolean;
-    get fieldsArray(): Array<Field<FieldValue>>;
+    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,10 +1,10 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { EventEmitter } from 'events';
-import * as moment from 'moment';
+import { EventEmitter } from 'node:events';
 import { RecordTypes } from '../types.js';
-import { Field } from './field.js';
+import { DateField, NumberField, TextField, TimeField, TimeStampField, ValueFieldBase } from "./fields/valueField.js";
+import { ContainerField } from "./fields/containerField.js";
 export class RecordBase extends EventEmitter {
     layout;
     type = RecordTypes.UNKNOWN;
@@ -17,65 +17,65 @@ 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
      *
      * @returns {boolean} A boolean value indicating whether any of the fields have been edited.
      */
     get edited() {
-        return !!this.fieldsArray.find(i => i.edited);
+        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) {
         const fields = {};
-        for (const key of Object.keys(fieldData)) {
-            const _field = new Field(this, key, fieldData[key]);
-            if (fieldData[key]) {
-                if (_field.metadata.result === 'timeStamp') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
-                else if (_field.metadata.result === 'time') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
-                else if (_field.metadata.result === 'date') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
+        for (const [key, value] of Object.entries(fieldData)) {
+            const fieldMeta = this.getFieldMetadata(key);
+            let field;
+            switch (fieldMeta.result) {
+                case "text":
+                    field = new TextField(this, key, value);
+                    break;
+                case "number":
+                    field = new NumberField(this, key, value);
+                    break;
+                case "container":
+                    field = new ContainerField(this, key, value);
+                    break;
+                case "timeStamp":
+                    field = new TimeStampField(this, key, value);
+                    break;
+                case "time":
+                    field = new TimeField(this, key, value);
+                    break;
+                case "date":
+                    field = new DateField(this, key, value);
+                    break;
+                default:
+                    throw new Error(`Attempted to parse unknown field type: ${fieldMeta.result}`);
             }
-            fields[key] = _field;
+            fields[key] = field;
         }
         this.fields = fields;
         return fields;
     }
     _onSave() {
         this.emit('saved');
-        for (const field of this.fieldsArray)
-            field.updateOriginalContents();
+        for (const field of this.fieldsArray) {
+            if (field instanceof ValueFieldBase)
+                field.updateOriginalContents();
+        }
     }
 }

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 {};

package/dist/typegen/dependencies.js

@@ -0,0 +1,67 @@
+import { access, readFile } from 'node:fs/promises';
+import { dirname, parse, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+const ZOD_VERSION = '^4.6.5';
+/** Ensures generated code can resolve its direct `zod` import. */
+export async function ensureZodInstalled(start) {
+    const plan = await getZodInstallPlan(start);
+    if (!plan)
+        return false;
+    await runInstall(plan);
+    return true;
+}
+/** Returns null when Zod is already declared. Exported for alternate CLIs. */
+export async function getZodInstallPlan(start) {
+    const packagePath = await findUp(resolve(start), 'package.json');
+    if (!packagePath)
+        throw new Error(`Cannot install Zod: no package.json found above ${resolve(start)}`);
+    const manifest = JSON.parse(await readFile(packagePath, 'utf8'));
+    const dependencyGroups = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+    if (dependencyGroups.some(group => hasDependency(manifest[group], 'zod')))
+        return null;
+    const cwd = dirname(packagePath);
+    const manager = await detectPackageManager(cwd, manifest.packageManager);
+    return { cwd, command: manager, args: installArguments(manager) };
+}
+function hasDependency(value, name) {
+    return typeof value === 'object' && value !== null && name in value;
+}
+async function detectPackageManager(cwd, declared) {
+    if (typeof declared === 'string') {
+        const name = declared.split('@')[0];
+        if (name === 'pnpm' || name === 'npm' || name === 'yarn' || name === 'bun')
+            return name;
+    }
+    const locks = [['pnpm-lock.yaml', 'pnpm'], ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'], ['package-lock.json', 'npm']];
+    for (const [file, manager] of locks)
+        if (await findUp(cwd, file))
+            return manager;
+    return 'npm';
+}
+function installArguments(manager) {
+    if (manager === 'npm')
+        return ['install', `zod@${ZOD_VERSION}`];
+    return ['add', `zod@${ZOD_VERSION}`];
+}
+async function runInstall({ cwd, command, args }) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(command, args, { cwd, stdio: 'inherit', shell: process.platform === 'win32' });
+        child.once('error', reject);
+        child.once('exit', code => code === 0 ? resolvePromise() : reject(new Error(`${command} ${args.join(' ')} exited with code ${code ?? 'unknown'}`)));
+    });
+}
+async function findUp(start, name) {
+    let directory = start;
+    while (true) {
+        const candidate = resolve(directory, name);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch { }
+        const parent = dirname(directory);
+        if (parent === directory || directory === parse(directory).root)
+            return undefined;
+        directory = parent;
+    }
+}

package/dist/typegen/generate.d.ts

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

package/dist/typegen/generate.js

@@ -0,0 +1,85 @@
+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 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 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 `/* 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')}
+
+${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}
+    }
+}
+`;
+}
+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 quote(value) { return JSON.stringify(value); }

package/dist/typegen/index.d.ts

@@ -0,0 +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 { 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';

package/dist/typegen/index.js

@@ -0,0 +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 { ensureZodInstalled, getZodInstallPlan } from './dependencies.js';
+export { defineTypegenConfig } from './types.js';

package/dist/typegen/init.d.ts

@@ -0,0 +1,13 @@
+export interface DataApiInitAnswers {
+    provider: 'data-api/odata';
+    transports: 'data-api' | 'odata' | 'both';
+    hostname: string;
+    database: string;
+    username: string;
+    password: string;
+    output: 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 readEnvironment(path: string): Promise<Record<string, string>>;

package/dist/typegen/init.js

@@ -0,0 +1,113 @@
+import { mkdir, open, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+export async function configExists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Non-interactive write step, usable by alternate setup UIs. */
+export async function writeDataApiInitialization(config, answers) {
+    const configPath = resolve(config);
+    const directory = dirname(configPath);
+    const envPath = resolve(directory, '.env');
+    await mkdir(directory, { recursive: true });
+    const file = await open(configPath, 'wx');
+    try {
+        await file.writeFile(renderConfig(answers), 'utf8');
+    }
+    finally {
+        await file.close();
+    }
+    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 readEnvironment(path) {
+    try {
+        const contents = await readFile(path, 'utf8');
+        return Object.fromEntries(contents.split(/\r?\n/).map(line => line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/)).filter(match => match).map(match => [match[1], decodeEnvironmentValue(match[2])]));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+}
+function renderConfig(answers) {
+    return `import {dataApiSchemaSource, defineTypegenConfig, zodTypegenValidator} from '@jd-data-limited/easy-fm/typegen'
+
+function required (name) {
+    const value = process.env[name]
+    if (!value) throw new Error(\`Missing required environment variable \${name}\`)
+    return value
+}
+
+export default defineTypegenConfig({
+    output: ${JSON.stringify(answers.output)},
+    transports: ${JSON.stringify(answers.transports === 'both' ? ['data-api', 'odata'] : [answers.transports])},
+    validator: zodTypegenValidator(),
+    source: dataApiSchemaSource({
+        hostname: required('FM_HOST'),
+        database: required('FM_DATABASE'),
+        credentials: {method: 'filemaker', username: required('FM_USERNAME'), password: required('FM_PASSWORD')},
+        externalSources: []
+    })
+})
+`;
+}
+async function updateEnvironment(path, values) {
+    let contents = '';
+    try {
+        contents = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const lines = contents ? contents.split(/\r?\n/) : [];
+    for (const [name, value] of Object.entries(values)) {
+        const replacement = `${name}=${JSON.stringify(value)}`;
+        const index = lines.findIndex(line => line.startsWith(`${name}=`));
+        if (index >= 0)
+            lines[index] = replacement;
+        else
+            lines.push(replacement);
+    }
+    await writeFile(path, `${lines.filter((line, index) => line || index < lines.length - 1).join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+}
+function decodeEnvironmentValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed.slice(1, -1);
+        }
+    }
+    return trimmed;
+}
+async function ensureEnvironmentIgnored(directory) {
+    const path = resolve(directory, '.gitignore');
+    let contents = '';
+    try {
+        contents = await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const alreadyIgnored = contents.split(/\r?\n/).some(line => {
+        const rule = line.trim();
+        return rule === '.env' || rule === '/.env' || rule === '.env*' || rule === '/.env*';
+    });
+    if (alreadyIgnored)
+        return;
+    const prefix = contents && !contents.endsWith('\n') ? '\n' : '';
+    await writeFile(path, `${contents}${prefix}.env\n`, 'utf8');
+}