@nitwel/sandbox 1.0.0

package/dist/docker/saml.yml

@@ -0,0 +1,10 @@
+services:
+  saml:
+    image: kristophjunge/test-saml-idp
+    ports:
+      - ${SAML_PORT}:8080
+    environment:
+      - SIMPLESAMLPHP_SP_ENTITY_ID=saml-test
+      - SIMPLESAMLPHP_SP_ASSERTION_CONSUMER_SERVICE=http://127.0.0.1:8080/auth/login/saml/acs
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './sandbox.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './sandbox.js';

package/dist/logger.d.ts

@@ -0,0 +1,18 @@
+import type Stream from 'stream';
+import type { Env } from './config.js';
+import type { Options } from './sandbox.js';
+export type Logger = {
+    addGroup: (group: string) => Logger;
+    fatal: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+    info: (msg: string) => void;
+    debug: (msg: string) => void;
+    pipe: (stream: Stream.Readable | null, type?: LogLevel) => void;
+    onLog: (listener: LogListener) => void;
+};
+export declare const logLevels: readonly ["fatal", "error", "warn", "info", "debug", "trace"];
+export type LogLevel = (typeof logLevels)[number];
+export type LogListener = (message: string, type: LogLevel, groups: string[]) => void;
+export declare function createLogger(env: Env, opts: Options, ...groups: string[]): Logger;
+export declare function log(env: Env, opts: Options, message: string, type?: LogLevel, ...groups: string[]): void;

package/dist/logger.js

@@ -0,0 +1,49 @@
+import chalk, {} from 'chalk';
+export const logLevels = ['fatal', 'error', 'warn', 'info', 'debug', 'trace'];
+const listeners = {};
+export function createLogger(env, opts, ...groups) {
+    return {
+        addGroup: (group) => {
+            return createLogger(env, opts, ...groups, group);
+        },
+        fatal: (msg) => log(env, opts, msg, 'fatal', ...groups),
+        error: (msg) => log(env, opts, msg, 'error', ...groups),
+        warn: (msg) => log(env, opts, msg, 'warn', ...groups),
+        info: (msg) => log(env, opts, msg, 'info', ...groups),
+        debug: (msg) => log(env, opts, msg, 'debug', ...groups),
+        pipe: (stream, type) => {
+            if (stream)
+                stream.on('data', (data) => log(env, opts, String(data), type, ...groups));
+        },
+        onLog: (listener) => {
+            const key = groups.join('.');
+            if (!listeners[key])
+                listeners[key] = [];
+            listeners[key].push(listener);
+        },
+    };
+}
+function logLevel(level) {
+    return logLevels.findIndex((l) => l === String(level).toLowerCase());
+}
+const logLevelColor = {
+    debug: 'blue',
+    error: 'red',
+    fatal: 'black',
+    info: 'green',
+    warn: 'yellow',
+    trace: 'blueBright',
+};
+export function log(env, opts, message, type = 'info', ...groups) {
+    const formattedMessage = groups.map((group) => chalk.blueBright(`[${group}] `)).join('') +
+        chalk[logLevelColor[type]](`[${type}] `) +
+        message +
+        (message.endsWith('\n') ? '' : '\n');
+    if (logLevel(env.LOG_LEVEL ?? 'info') >= logLevel(type) && (!opts.silent || type === 'error' || type === 'fatal'))
+        process.stdout.write(formattedMessage);
+    for (const [key, listener] of Object.entries(listeners)) {
+        if (groups.join('.').startsWith(key)) {
+            listener.forEach((l) => l(message, type, groups));
+        }
+    }
+}

package/dist/relation.d.ts

@@ -0,0 +1,5 @@
+import type { Relation } from '@directus/types';
+export declare function getRelationInfo(relations: Relation[], collection: string, field: string): {
+    relation: Relation;
+    relationType: "m2o" | "o2m" | "m2a";
+} | undefined;

package/dist/relation.js

@@ -0,0 +1,8 @@
+import { getRelation, getRelationType } from '@directus/utils';
+export function getRelationInfo(relations, collection, field) {
+    const relation = getRelation(relations, collection, field) ?? null;
+    if (!relation)
+        return undefined;
+    const relationType = getRelationType({ relation, collection, field });
+    return { relation, relationType };
+}

package/dist/sandbox.d.ts

@@ -0,0 +1,81 @@
+import type { DatabaseClient, DeepPartial } from '@directus/types';
+import { type Env } from './config.js';
+import { type Logger } from './logger.js';
+export type { Env } from './config.js';
+export type Database = Exclude<DatabaseClient, 'redshift'> | 'maria';
+type Port = string | number;
+export type Options = {
+    /** Rebuild directus from source */
+    build: boolean;
+    /** Start directus in developer mode. Not compatible with build */
+    dev: boolean;
+    /** Restart the api when changes are made */
+    watch: boolean;
+    /** Port to start the api on */
+    port: Port;
+    /** Which version of the database to use */
+    version: string | undefined;
+    /** Configure the behavior of the spun up docker container */
+    docker: {
+        /** Keep containers running when stopping the sandbox */
+        keep: boolean;
+        /** Minimum port number to use for docker containers */
+        basePort: Port | (() => Port | Promise<Port>);
+        /** Overwrite the name of the docker project */
+        name: string | undefined;
+        /** Adds a suffix to the docker project. Can be used to ensure uniqueness */
+        suffix: string;
+    };
+    /** Horizontally scale the api to a given number of instances */
+    instances: string;
+    /** Add environment variables that the api should start with */
+    env: Record<string, string>;
+    /** Prefix the logs, useful when starting multiple sandboxes */
+    prefix: string | undefined;
+    /** Exports a snapshot and type definition every 2 seconds */
+    export: boolean;
+    /** Silence all logs except for errors */
+    silent: boolean;
+    /** Load an additional schema snapshot on startup */
+    schema: string | undefined;
+    /** Start the api with debugger */
+    inspect: boolean;
+    /** Forcefully kills all processes that occupy ports that the api would use */
+    killPorts: boolean;
+    /** Enable redis,maildev,saml or other extras */
+    extras: {
+        /** Used for caching, forced to true if instances > 1 */
+        redis: boolean;
+        /** Auth provider */
+        saml: boolean;
+        /** Storage provider */
+        minio: boolean;
+        /** Email server */
+        maildev: boolean;
+    };
+    /** Enable or disable caching */
+    cache: boolean;
+};
+export type Sandboxes = {
+    sandboxes: {
+        index: number;
+        env: Env;
+        logger: Logger;
+    }[];
+    restartApis(): Promise<void>;
+    stop(): Promise<void>;
+};
+export type Sandbox = {
+    restartApi(): Promise<void>;
+    stop(): Promise<void>;
+    env: Env;
+    logger: Logger;
+};
+export declare const apiFolder: string;
+export declare const databases: Database[];
+export type SandboxesOptions = {
+    database: Database;
+    options: DeepPartial<Omit<Options, 'build' | 'dev' | 'watch' | 'export'>>;
+}[];
+export declare function sandboxes(sandboxes: SandboxesOptions, options?: Partial<Pick<Options, 'build' | 'dev' | 'watch'>>): Promise<Sandboxes>;
+export declare function sandbox(database: Database, options?: DeepPartial<Options>): Promise<Sandbox>;

package/dist/sandbox.js

@@ -0,0 +1,144 @@
+import {} from 'child_process';
+import { merge } from 'lodash-es';
+import { join } from 'path';
+import { getEnv } from './config.js';
+import { createLogger } from './logger.js';
+import { buildDirectus, bootstrap, dockerDown, dockerUp, loadSchema, saveSchema, startDirectus, } from './steps/index.js';
+import chalk from 'chalk';
+import getPort from 'get-port';
+async function getOptions(options) {
+    if (options?.schema === true)
+        options.schema = 'snapshot.json';
+    const port = await getPort({ port: 8055 });
+    return merge({
+        build: false,
+        dev: false,
+        watch: false,
+        port,
+        version: undefined,
+        docker: {
+            keep: false,
+            basePort: port + 100,
+            name: undefined,
+            suffix: '',
+        },
+        instances: '1',
+        inspect: true,
+        env: {},
+        prefix: undefined,
+        schema: undefined,
+        silent: false,
+        export: false,
+        killPorts: false,
+        extras: {
+            redis: false,
+            maildev: false,
+            minio: false,
+            saml: false,
+        },
+        cache: false,
+    }, options);
+}
+export const apiFolder = join(import.meta.dirname, '..', '..', '..', 'api');
+export const databases = [
+    'maria',
+    'cockroachdb',
+    'mssql',
+    'mysql',
+    'oracle',
+    'postgres',
+    'sqlite',
+];
+export async function sandboxes(sandboxes, options) {
+    if (!sandboxes.every((sandbox) => databases.includes(sandbox.database)))
+        throw new Error('Invalid database provided');
+    const opts = await getOptions(options);
+    const logger = createLogger(process.env, opts);
+    let apis = [];
+    let build;
+    const projects = [];
+    try {
+        // Rebuild directus
+        if (opts.build && !opts.dev) {
+            build = await buildDirectus(opts, logger, restartApis);
+        }
+        await Promise.all(sandboxes.map(async ({ database, options }, index) => {
+            const opts = await getOptions(options);
+            const env = await getEnv(database, opts);
+            const logger = opts.prefix ? createLogger(env, opts, opts.prefix) : createLogger(env, opts);
+            try {
+                const project = await dockerUp(database, opts, env, logger);
+                if (project)
+                    projects.push({ project, logger, env });
+                await bootstrap(env, logger);
+                if (opts.schema)
+                    await loadSchema(opts.schema, env, logger);
+                apis.push({ processes: await startDirectus(opts, env, logger), index, opts, env, logger });
+            }
+            catch (e) {
+                logger.error(String(e));
+                throw e;
+            }
+        }));
+    }
+    catch (e) {
+        await stop();
+        throw e;
+    }
+    async function restartApis() {
+        apis.forEach((api) => api.processes.forEach((process) => process.kill()));
+        apis = await Promise.all(apis.map(async (api) => ({ ...api, processes: await startDirectus(api.opts, api.env, api.logger) })));
+    }
+    async function stop() {
+        build?.kill();
+        apis.forEach((api) => api.processes.forEach((process) => process.kill()));
+        if (opts.docker.keep)
+            await Promise.all(projects.map(({ project, logger, env }) => dockerDown(project, env, logger)));
+    }
+    return { sandboxes: apis.map(({ env, index, logger }) => ({ index, env, logger })), stop, restartApis };
+}
+export async function sandbox(database, options) {
+    if (!databases.includes(database))
+        throw new Error('Invalid database provided');
+    const opts = await getOptions(options);
+    const env = await getEnv(database, opts);
+    const logger = opts.prefix ? createLogger(env, opts, opts.prefix) : createLogger(env, opts);
+    let apis = [];
+    let project;
+    let build;
+    let interval;
+    try {
+        // Rebuild directus
+        if (opts.build && !opts.dev) {
+            build = await buildDirectus(opts, logger, restartApi);
+        }
+        project = await dockerUp(database, opts, env, logger);
+        await bootstrap(env, logger);
+        if (opts.schema)
+            await loadSchema(opts.schema, env, logger);
+        apis = await startDirectus(opts, env, logger);
+        if (opts.export)
+            interval = await saveSchema(env);
+    }
+    catch (err) {
+        logger.error(err.toString());
+        await stop();
+        throw err;
+    }
+    async function restartApi() {
+        apis.forEach((api) => api.kill());
+        apis = await startDirectus(opts, env, logger);
+    }
+    async function stop() {
+        const start = performance.now();
+        logger.info('Stopping sandbox');
+        clearInterval(interval);
+        build?.kill();
+        apis.forEach((api) => api.kill());
+        if (project && !opts.docker.keep)
+            await dockerDown(project, env, logger);
+        const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+        logger.info(`Stopped sandbox ${time}`);
+    }
+    return { stop, restartApi, env, logger };
+}

package/dist/steps/api.d.ts

@@ -0,0 +1,6 @@
+import { type Env } from '../config.js';
+import { type Logger } from '../logger.js';
+import { type Options } from '../sandbox.js';
+export declare function buildDirectus(opts: Options, logger: Logger, onRebuild: () => void): Promise<import("child_process").ChildProcessWithoutNullStreams | undefined>;
+export declare function bootstrap(env: Env, logger: Logger): Promise<void>;
+export declare function startDirectus(opts: Options, env: Env, logger: Logger): Promise<import("child_process").ChildProcessWithoutNullStreams[]>;

package/dist/steps/api.js

@@ -0,0 +1,170 @@
+import { spawn } from 'child_process';
+import { join } from 'path';
+import {} from '../config.js';
+import {} from '../logger.js';
+import { apiFolder } from '../sandbox.js';
+import chalk from 'chalk';
+import { portToPid } from 'pid-port';
+import { createInterface } from 'readline/promises';
+export async function buildDirectus(opts, logger, onRebuild) {
+    const start = performance.now();
+    logger.info('Rebuilding Directus');
+    let timeout;
+    const watch = opts.watch ? ['--watch', '--preserveWatchOutput'] : [];
+    const inspect = opts.inspect ? ['--sourceMap'] : [];
+    const build = spawn('pnpm', ['tsc', ...watch, ...inspect, '--project tsconfig.prod.json'], {
+        cwd: apiFolder,
+        shell: true,
+    });
+    build.on('error', (err) => {
+        logger.error(err.toString());
+    });
+    build.on('close', (code) => {
+        if (code === null || code === 0)
+            return;
+        build.kill();
+        const error = new Error(`Building api stopped with error code ${code}`);
+        clearTimeout(timeout);
+        logger.error(error.toString());
+        throw error;
+    });
+    logger.pipe(build.stderr, 'error');
+    if (opts.watch) {
+        await new Promise((resolve, reject) => {
+            build.stdout.on('data', (data) => {
+                logger.debug(String(data));
+                if (String(data).includes(`Watching for file changes.`)) {
+                    onRebuild();
+                    resolve(undefined);
+                }
+            });
+            // In case the api takes too long to start
+            timeout = setTimeout(() => reject(new Error('timeout building directus')), 60_000);
+        });
+        return build;
+    }
+    else {
+        logger.pipe(build.stdout);
+        await new Promise((resolve) => build.on('close', resolve));
+        const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+        logger.info(`New Build Completed ${time}`);
+        return;
+    }
+}
+export async function bootstrap(env, logger) {
+    const start = performance.now();
+    logger.info('Bootstraping Database');
+    const bootstrap = spawn('node', [join(apiFolder, 'dist', 'cli', 'run.js'), 'bootstrap'], {
+        env,
+    });
+    bootstrap.on('error', (err) => {
+        bootstrap.kill();
+        throw err;
+    });
+    logger.pipe(bootstrap.stdout, 'debug');
+    logger.pipe(bootstrap.stderr, 'error');
+    await new Promise((resolve) => bootstrap.on('close', resolve));
+    const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+    logger.info(`Completed Bootstraping Database ${time}`);
+}
+export async function startDirectus(opts, env, logger) {
+    const apiCount = Math.max(1, Number(opts.instances));
+    const apiPorts = [...Array(apiCount).keys()].flatMap((i) => Number(env.PORT) + i * (opts.inspect ? 2 : 1));
+    const allPorts = apiPorts.flatMap((port) => (opts.inspect ? [port, port + 1] : [port]));
+    const occupiedPorts = (await Promise.allSettled(allPorts.map((port) => portToPid(port))))
+        .map((result, i) => (result.status === 'fulfilled' ? [result.value, allPorts[i]] : undefined))
+        .filter((val) => val);
+    let killPorts;
+    for (const [pid, port] of occupiedPorts) {
+        logger.warn(`Port ${port} is occupied by pid ${pid}`);
+    }
+    if (opts.killPorts) {
+        killPorts = true;
+    }
+    else {
+        if (occupiedPorts.length > 0) {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const result = (await rl.question('Would you like to kill all occupying processes? (Y/N) ')).toLowerCase();
+            killPorts = result === 'y' || result === 'yes';
+        }
+    }
+    if (killPorts) {
+        for (const [pid] of occupiedPorts) {
+            try {
+                process.kill(pid, 'SIGKILL');
+                logger.info(`Killed process ${pid}`);
+            }
+            catch (err) {
+                logger.error(`Failed to kill process ${pid}: ${err.message}`);
+            }
+        }
+    }
+    return await Promise.all(apiPorts.map((port) => {
+        const newLogger = apiCount > 1 ? logger.addGroup(`API ${port}`) : logger;
+        return startDirectusInstance(opts, { ...env, PORT: String(port) }, newLogger);
+    }));
+}
+async function startDirectusInstance(opts, env, logger) {
+    const start = performance.now();
+    logger.info('Starting Directus');
+    const debuggerPort = Number(env.PORT) + 1;
+    let api;
+    let timeout;
+    const inspect = opts.inspect ? [`--inspect=${debuggerPort}`] : [];
+    if (opts.dev) {
+        const watch = opts.watch ? ['watch', '--clear-screen=false'] : [];
+        api = spawn('pnpm ', ['tsx', ...watch, ...inspect, join(apiFolder, 'src', 'start.ts')], {
+            env,
+            shell: true,
+            stdio: 'overlapped', // Has to be here, only god knows why.
+        });
+    }
+    else {
+        api = spawn('node', [...inspect, join(apiFolder, 'dist', 'cli', 'run.js'), 'start'], {
+            env,
+        });
+    }
+    api.on('error', (err) => {
+        logger.error(err.toString());
+    });
+    api.on('close', (code) => {
+        if (code === null || code === 0)
+            return;
+        const error = new Error(`Api stopped with error code ${code}`);
+        clearTimeout(timeout);
+        logger.error(error.toString());
+        throw error;
+    });
+    api.stderr.on('data', (data) => {
+        const msg = String(data);
+        if (msg.startsWith('Debugger listening on ws://'))
+            return;
+        if (msg.startsWith('Debugger attached')) {
+            logger.info(msg);
+            return;
+        }
+        logger.error(msg);
+    });
+    await new Promise((resolve, reject) => {
+        api.stdout.on('data', (data) => {
+            const msg = String(data);
+            if (msg.includes(`Server started at http://${env.HOST}:${env.PORT}`)) {
+                resolve(undefined);
+            }
+            else if (msg.includes(`ERROR: Port ${env.PORT} is already in use`)) {
+                reject(new Error(msg));
+            }
+            else {
+                logger.debug(msg);
+            }
+        });
+        // In case the api takes too long to start
+        timeout = setTimeout(() => {
+            reject(new Error('timeout starting directus'));
+        }, 60_000);
+    });
+    const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+    logger.info(`Server started at http://${env.HOST}:${env.PORT}, Debugger listening on http://${env.HOST}:${debuggerPort} ${time}`);
+    logger.info(`User: ${chalk.cyan(env.ADMIN_EMAIL)} Password: ${chalk.cyan(env.ADMIN_PASSWORD)} Token: ${chalk.cyan(env.ADMIN_TOKEN)}`);
+    return api;
+}

package/dist/steps/docker.d.ts

@@ -0,0 +1,5 @@
+import { type Env } from '../config.js';
+import { type Logger } from '../logger.js';
+import type { Database, Options } from '../sandbox.js';
+export declare function dockerUp(database: Database, opts: Options, env: Env, logger: Logger): Promise<string | undefined>;
+export declare function dockerDown(project: string, env: Env, logger: Logger): Promise<void>;

package/dist/steps/docker.js

@@ -0,0 +1,63 @@
+import { spawn } from 'child_process';
+import { join } from 'path';
+import {} from '../config.js';
+import {} from '../logger.js';
+import chalk from 'chalk';
+export async function dockerUp(database, opts, env, logger) {
+    const start = performance.now();
+    logger.info('Starting up Docker containers');
+    const extrasList = Object.entries(opts.extras)
+        .filter(([_, value]) => value)
+        .map(([key, _]) => key);
+    const project = opts.docker.name ??
+        `sandbox_${database}${extrasList.map((extra) => '_' + extra).join('')}` +
+            (opts.docker.suffix ? `_${opts.docker.suffix}` : '');
+    const files = database === 'sqlite' ? extrasList : [database, ...extrasList];
+    if (files.length === 0)
+        return;
+    const docker = spawn('docker', [
+        'compose',
+        '-p',
+        project,
+        ...files.flatMap((file) => ['-f', join(import.meta.dirname, '..', 'docker', `${file}.yml`)]),
+        'up',
+        '-d',
+        '--wait',
+    ], {
+        env: {
+            ...env,
+            COMPOSE_STATUS_STDOUT: '1', //Ref: https://github.com/docker/compose/issues/7346
+        },
+    });
+    docker.on('error', (err) => {
+        docker.kill();
+        throw err;
+    });
+    logger.pipe(docker.stdout, 'debug');
+    logger.pipe(docker.stderr, 'error');
+    await new Promise((resolve) => docker.on('close', resolve));
+    const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+    if ('DB_PORT' in env) {
+        logger.info(`Database started at ${env.DB_HOST}:${env.DB_PORT}/${env.DB_DATABASE} ${time}`);
+        logger.info(`User: ${chalk.cyan(env.DB_USER)} Password: ${chalk.cyan(env.DB_PASSWORD)}`);
+    }
+    else if ('DB_FILENAME' in env)
+        logger.info(`Database stored at ${env.DB_FILENAME} ${time}`);
+    return project;
+}
+export async function dockerDown(project, env, logger) {
+    const start = performance.now();
+    logger.info('Stopping docker containers');
+    const docker = spawn('docker', ['compose', '-p', project, 'down'], {
+        env: { ...env, COMPOSE_STATUS_STDOUT: '1' },
+    });
+    docker.on('error', (err) => {
+        docker.kill();
+        throw err;
+    });
+    logger.pipe(docker.stdout, 'debug');
+    logger.pipe(docker.stderr, 'error');
+    await new Promise((resolve) => docker.on('close', resolve));
+    const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+    logger.info(`Docker containers stopped ${time}`);
+}

package/dist/steps/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './docker.js';
+export * from './schema.js';

package/dist/steps/index.js

@@ -0,0 +1,3 @@
+export * from './api.js';
+export * from './docker.js';
+export * from './schema.js';

package/dist/steps/schema.d.ts

@@ -0,0 +1,4 @@
+import { type Env } from '../config.js';
+import { type Logger } from '../logger.js';
+export declare function loadSchema(schema_file: string, env: Env, logger: Logger): Promise<void>;
+export declare function saveSchema(env: Env): Promise<NodeJS.Timeout>;

package/dist/steps/schema.js

@@ -0,0 +1,78 @@
+import { spawn } from 'child_process';
+import { writeFile } from 'fs/promises';
+import { camelCase, upperFirst } from 'lodash-es';
+import { join, resolve } from 'path';
+import {} from '../config.js';
+import {} from '../logger.js';
+import { getRelationInfo } from '../relation.js';
+import { apiFolder } from '../sandbox.js';
+import chalk from 'chalk';
+export async function loadSchema(schema_file, env, logger) {
+    const start = performance.now();
+    logger.info('Applying Schema');
+    const schema = spawn('node', [join(apiFolder, 'dist', 'cli', 'run.js'), 'schema', 'apply', '-y', resolve(schema_file)], {
+        env,
+    });
+    schema.on('error', (err) => {
+        schema.kill();
+        throw err;
+    });
+    logger.pipe(schema.stdout, 'debug');
+    logger.pipe(schema.stderr, 'error');
+    await new Promise((resolve) => schema.on('close', resolve));
+    const time = chalk.gray(`(${Math.round(performance.now() - start)}ms)`);
+    logger.info(`Schema Applied ${time}`);
+}
+export async function saveSchema(env) {
+    return setInterval(async () => {
+        const data = await fetch(`${env.PUBLIC_URL}/schema/snapshot?access_token=${env.ADMIN_TOKEN}`);
+        const snapshot = (await data.json());
+        const collections = snapshot.data.collections.filter((collection) => collection.schema);
+        const schema = `export type Schema = {
+	${collections
+            .map((collection) => {
+            const collectionName = formatCollection(collection.collection);
+            if (collection.meta?.singleton)
+                return `${formatField(collection.collection)}: ${collectionName}`;
+            return `${formatField(collection.collection)}: ${collectionName}[];`;
+        })
+            .join('\n	')}
+};
+`;
+        const collectionTypes = collections
+            .map((collection) => {
+            const collectionName = formatCollection(collection.collection);
+            return `export type ${collectionName} = {
+	${snapshot.data.fields
+                .filter((field) => field.collection === collection.collection)
+                .map((field) => {
+                const rel = getRelationInfo(snapshot.data.relations, collection.collection, field.field);
+                const optional = field.schema?.is_nullable || field.schema?.is_generated || field.schema?.is_primary_key;
+                const fieldName = `${formatField(field.field)}${optional ? '?' : ''}:`;
+                if (!rel)
+                    return `${fieldName} string | number;`;
+                const { relation, relationType } = rel;
+                if (relationType === 'o2m') {
+                    return `${fieldName} (string | number | ${formatCollection(relation.collection)})[];`;
+                }
+                else if (relationType === 'm2o') {
+                    return `${fieldName} string | number | ${formatCollection(relation.related_collection)};`;
+                }
+                else {
+                    return `${fieldName} string | number | ${relation.meta.one_allowed_collections.map(formatCollection).join(' | ')};`;
+                }
+            })
+                .join('\n	')}
+};`;
+        })
+            .join('\n');
+        await writeFile('schema.d.ts', schema + collectionTypes);
+        await writeFile('snapshot.json', JSON.stringify(snapshot.data, null, 4));
+    }, 2000);
+}
+function formatCollection(title) {
+    return upperFirst(camelCase(title.replaceAll('_1234', '')));
+}
+function formatField(title) {
+    return title.replaceAll('_1234', '');
+}