remult 0.25.8 → 0.26.0

package/esm/graphql.js

@@ -118,6 +118,11 @@ export function remultGraphql(options) {
     for (const meta of entities) {
         const orderByFields = [];
         const key = meta.key;
+        const requiredWhereArg = {
+            key: 'where',
+            value: `${key}Where!`,
+            comment: `Remult filtering options`,
+        };
         const currentType = upsertTypes(getMetaType(meta), 'type_impl_node');
         if (key) {
             const createResultPromise = (work) => {
@@ -213,6 +218,7 @@ export function remultGraphql(options) {
                 });
             };
             const queryArgsConnection = getQueryArgsConnection(key);
+            let pluralEntityKey = key;
             let getSingleEntityKey = toCamelCase(getMetaType(meta));
             if (getSingleEntityKey === toCamelCase(key))
                 getSingleEntityKey = 'single' + key;
@@ -325,66 +331,126 @@ export function remultGraphql(options) {
             if (checkCanExist(meta.options.allowApiUpdate)) {
                 // update
                 const updateInput = `Update${getMetaType(meta)}Input`;
-                const updatePayload = `Update${getMetaType(meta)}Payload`;
-                const updateResolverKey = `update${getMetaType(meta)}`;
-                root_mutation.fields.push({
-                    key: updateResolverKey,
-                    args: [
-                        argId,
-                        { key: 'patch', value: `${updateInput}!` },
-                        argClientMutationId,
-                    ],
-                    value: `${updatePayload}`,
-                    comment: `Update a \`${getMetaType(meta)}\``,
-                });
-                currentType.mutation.update.input = upsertTypes(updateInput, 'input');
-                currentType.mutation.update.payload = upsertTypes(updatePayload);
-                currentType.mutation.update.payload.fields.push({
-                    key: `${toCamelCase(getMetaType(meta))}`,
-                    value: `${getMetaType(meta)}`,
-                }, argErrorDetail, argClientMutationId);
-                root[updateResolverKey] = handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
-                    await dApi.put({
-                        ...response,
-                        success: (y) => {
-                            const orig = { ...y };
-                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
-                            setResult({
-                                [toCamelCase(getMetaType(meta))]: y,
-                            });
-                        },
-                    }, arg1.id, arg1.patch);
-                });
-                resolversMutation[updateResolverKey] = (origItem, args, req, gqlInfo) => root[updateResolverKey](args, req, gqlInfo);
+                {
+                    const updatePayload = `Update${getMetaType(meta)}Payload`;
+                    const updateResolverKey = `update${getMetaType(meta)}`;
+                    root_mutation.fields.push({
+                        key: updateResolverKey,
+                        args: [
+                            argId,
+                            { key: 'patch', value: `${updateInput}!` },
+                            argClientMutationId,
+                        ],
+                        value: `${updatePayload}`,
+                        comment: `Update a \`${getMetaType(meta)}\``,
+                    });
+                    currentType.mutation.update.input = upsertTypes(updateInput, 'input');
+                    currentType.mutation.update.payload = upsertTypes(updatePayload);
+                    currentType.mutation.update.payload.fields.push({
+                        key: `${toCamelCase(getMetaType(meta))}`,
+                        value: `${getMetaType(meta)}`,
+                    }, argErrorDetail, argClientMutationId);
+                    resolversMutation[updateResolverKey] = (origItem, args, req, gqlInfo) => handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
+                        await dApi.put({
+                            ...response,
+                            success: (y) => {
+                                const orig = { ...y };
+                                currentType.query.resultProcessors.forEach((z) => z(y, orig));
+                                setResult({
+                                    [toCamelCase(getMetaType(meta))]: y,
+                                });
+                            },
+                        }, arg1.id, arg1.patch);
+                    })(args, req);
+                }
+                // update many
+                {
+                    const updateManyPayload = `UpdateMany${upperFirstChar(pluralEntityKey)}Payload`;
+                    const updateManyResolverKey = `updateMany${upperFirstChar(pluralEntityKey)}`;
+                    root_mutation.fields.push({
+                        key: updateManyResolverKey,
+                        args: [
+                            requiredWhereArg,
+                            { key: 'patch', value: `${updateInput}!` },
+                            argClientMutationId,
+                        ],
+                        value: `${updateManyPayload}`,
+                        comment: `Update many \`${pluralEntityKey}\``,
+                    });
+                    currentType.mutation.update.payload = upsertTypes(updateManyPayload);
+                    currentType.mutation.update.payload.fields.push({
+                        key: `updated`,
+                        value: `Int!`,
+                    }, argErrorDetail, argClientMutationId);
+                    resolversMutation[updateManyResolverKey] = (origItem, args, req, gqlInfo) => handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
+                        await dApi.updateManyImplementation({
+                            ...response,
+                            success: (updateManyResult) => {
+                                setResult(updateManyResult);
+                            },
+                        }, { get: () => undefined }, {
+                            ...translateWhereToRestBody(meta.fields, arg1),
+                            set: arg1.patch,
+                        });
+                    })(args, req);
+                }
             }
             if (checkCanExist(meta.options.allowApiDelete)) {
                 // delete
-                const deletePayload = `Delete${getMetaType(meta)}Payload`;
-                const deleteResolverKey = `delete${getMetaType(meta)}`;
-                root_mutation.fields.push({
-                    key: deleteResolverKey,
-                    args: [argId, argClientMutationId],
-                    value: `${deletePayload}`,
-                    comment: `Delete a \`${getMetaType(meta)}\``,
-                });
-                currentType.mutation.delete.payload = upsertTypes(deletePayload);
-                const deletedResultKey = `id`;
-                const type = meta.idMetadata.field instanceof CompoundIdField
-                    ? 'String'
-                    : getGraphqlBaseType(meta.idMetadata.field);
-                currentType.mutation.delete.payload.fields.push({
-                    key: deletedResultKey,
-                    value: `${type}`,
-                }, argErrorDetail, argClientMutationId);
-                root[deleteResolverKey] = handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
-                    await dApi.delete({
-                        ...response,
-                        deleted: () => {
-                            setResult({ [deletedResultKey]: arg1.id });
-                        },
-                    }, arg1.id);
-                });
-                resolversMutation[deleteResolverKey] = (origItem, args, req, gqlInfo) => root[deleteResolverKey](args, req, gqlInfo);
+                {
+                    const deletePayload = `Delete${getMetaType(meta)}Payload`;
+                    const deleteResolverKey = `delete${getMetaType(meta)}`;
+                    root_mutation.fields.push({
+                        key: deleteResolverKey,
+                        args: [argId, argClientMutationId],
+                        value: `${deletePayload}`,
+                        comment: `Delete a \`${getMetaType(meta)}\``,
+                    });
+                    currentType.mutation.delete.payload = upsertTypes(deletePayload);
+                    const deletedResultKey = `id`;
+                    const type = meta.idMetadata.field instanceof CompoundIdField
+                        ? 'String'
+                        : getGraphqlBaseType(meta.idMetadata.field);
+                    currentType.mutation.delete.payload.fields.push({
+                        key: deletedResultKey,
+                        value: `${type}`,
+                    }, argErrorDetail, argClientMutationId);
+                    resolversMutation[deleteResolverKey] = (origItem, args, req) => handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
+                        await dApi.delete({
+                            ...response,
+                            deleted: () => {
+                                setResult({ [deletedResultKey]: arg1.id });
+                            },
+                        }, arg1.id);
+                    })(args, req);
+                }
+                // delete
+                {
+                    const deleteManyPayload = `DeleteMany${upperFirstChar(pluralEntityKey)}Payload`;
+                    const deleteManyResolverKey = `deleteMany${upperFirstChar(pluralEntityKey)}`;
+                    root_mutation.fields.push({
+                        key: deleteManyResolverKey,
+                        args: [requiredWhereArg, argClientMutationId],
+                        value: `${deleteManyPayload}`,
+                        comment: `Delete many \`${pluralEntityKey}\``,
+                    });
+                    currentType.mutation.delete.payload = upsertTypes(deleteManyPayload);
+                    const type = meta.idMetadata.field instanceof CompoundIdField
+                        ? 'String'
+                        : getGraphqlBaseType(meta.idMetadata.field);
+                    currentType.mutation.delete.payload.fields.push({
+                        key: 'deleted',
+                        value: `Int!`,
+                    }, argErrorDetail, argClientMutationId);
+                    resolversMutation[deleteManyResolverKey] = (origItem, args, req) => handleMutationWithErrors(async (dApi, response, setResult, arg1, req) => {
+                        await dApi.deleteMany({
+                            ...response,
+                            success: (deleteManyResult) => {
+                                setResult(deleteManyResult);
+                            },
+                        }, { get: () => undefined }, translateWhereToRestBody(meta.fields, arg1));
+                    })(args, req);
+                }
             }
             const whereTypeFields = [];
             for (const f of meta.fields) {
@@ -838,6 +904,12 @@ function getGraphqlBaseType(field) {
 function getMetaType(entityMeta) {
     return entityMeta.entityType.name;
 }
+function upperFirstChar(str) {
+    return str
+        .split('')
+        .map((c, i) => (i === 0 ? c.toUpperCase() : c))
+        .join('');
+}
 function toCamelCase(str) {
     return str
         .split('')
@@ -904,7 +976,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }));
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
     }
-    return result;
+    return { where: result };
 }

package/esm/index.js

@@ -13,7 +13,7 @@ export { CustomSqlFilterBuilder, dbNamesOf, } from './src/filter/filter-consumer
 export { JsonDataProvider, } from './src/data-providers/json-data-provider.js'; //V
 export { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
 //export * from './src/data-api'; //reconsider if to make internal
-export { Controller, BackendMethod, ProgressListener, } from './src/server-action.js';
+export { Controller, BackendMethod, ProgressListener, ForbiddenError, } from './src/server-action.js';
 export { Allow, Remult, withRemult, isBackend, EventSource, } from './src/context.js';
 export { Sort } from './src/sort.js';
 export { CompoundIdField } from './src/CompoundIdField.js';

package/esm/migrations/compare-migration-snapshots.js

@@ -0,0 +1,61 @@
+import { repo } from '../index.js';
+import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+export async function compareMigrationSnapshot({ entities, snapshot, migrationBuilder, reporter, }) {
+    snapshot = JSON.parse(JSON.stringify(snapshot));
+    let processedEntities = new Set();
+    for (const entity of entities) {
+        const meta = repo(entity).metadata;
+        const e = await dbNamesOf(meta, (x) => x);
+        processedEntities.add(e.$entityName);
+        if (shouldCreateEntity(meta, e)) {
+            let entitySnapshot = snapshot.entities[e.$entityName];
+            let createColumns = true;
+            if (!entitySnapshot) {
+                createColumns = false;
+                reporter('create table ' + e.$entityName);
+                await migrationBuilder.createTable(meta);
+                entitySnapshot = snapshot.entities[e.$entityName] = {
+                    key: meta.key,
+                    className: meta.entityType.name,
+                    columns: {},
+                };
+            }
+            const processedColumns = new Set();
+            for (const field of meta.fields) {
+                if (!shouldNotCreateField(field, e)) {
+                    const columnDbName = e.$dbNameOf(field);
+                    processedColumns.add(columnDbName);
+                    const column = entitySnapshot.columns[columnDbName];
+                    if (!column) {
+                        if (createColumns) {
+                            reporter('add column ' + e.$entityName + '.' + columnDbName);
+                            await migrationBuilder.addColumn(meta, field);
+                        }
+                        entitySnapshot.columns[columnDbName] = { key: field.key };
+                    }
+                }
+            }
+            for (const columnDbName of Object.keys(entitySnapshot.columns)) {
+                if (!processedColumns.has(columnDbName)) {
+                    reporter('remove column ' + e.$entityName + '.' + columnDbName);
+                    await migrationBuilder.removeColumn(e.$entityName, columnDbName);
+                    delete entitySnapshot.columns[columnDbName];
+                }
+            }
+        }
+    }
+    for (const entityDbName of Object.keys(snapshot.entities)) {
+        if (!processedEntities.has(entityDbName)) {
+            reporter('remove table ' + entityDbName);
+            await migrationBuilder.removeTable(entityDbName);
+            delete snapshot.entities[entityDbName];
+        }
+    }
+    return snapshot;
+}
+export function emptySnapshot() {
+    return {
+        version: 1,
+        entities: {},
+    };
+}

package/esm/migrations/generate-migrations.js

@@ -0,0 +1,68 @@
+import path from 'path';
+import fs from 'fs';
+import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-snapshots.js';
+import { updateMigrationsFile } from './update-migrations-ts-file.js';
+import { DefaultMigrationBuilder, } from './migration-types.js';
+import { isOfType } from '../src/isOfType.js';
+import { initDataProvider } from '../server/initDataProvider.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes whose changes will be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is false.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export async function generateMigrations(options) {
+    const migrationDir = options.migrationsFolder || path.join(process.cwd(), 'src/migrations');
+    const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
+    const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
+    const dataProvider = await initDataProvider(options.dataProvider);
+    for (const p of [snapshotFileName, migrationsTSFilename]) {
+        if (!fs.existsSync(path.dirname(p))) {
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+        }
+    }
+    let snapshot = emptySnapshot();
+    if (fs.existsSync(snapshotFileName)) {
+        snapshot = JSON.parse(fs.readFileSync(snapshotFileName).toString());
+    }
+    let hasSql = false;
+    let steps = [];
+    const code = {
+        //https://marketplace.visualstudio.com/items?itemName=qufiwefefwoyn.inline-sql-syntax
+        addSql: (sql) => {
+            steps.push('await sql(`--sql\n' + sql + '`)');
+            hasSql = true;
+        },
+        addTypescriptCode: (code) => steps.push(code),
+        addComment: (comment) => steps.push(comment.indexOf('\n') >= 0 ? `/*${comment}*/` : `// ${comment}`),
+    };
+    let migrationBuilder = new DefaultMigrationBuilder(code);
+    if (isOfType(dataProvider, 'provideMigrationBuilder')) {
+        migrationBuilder = new DefaultMigrationBuilder(code, dataProvider.provideMigrationBuilder(code));
+    }
+    let reporter = (what) => console.log('[generateMigrations] ' + what);
+    snapshot = await compareMigrationSnapshot({
+        entities: options.entities,
+        snapshot,
+        reporter,
+        migrationBuilder,
+    });
+    if (steps.length)
+        await updateMigrationsFile(migrationsTSFilename, [
+            `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
+        ]);
+    else {
+        reporter('No changes detected');
+    }
+    fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+    return steps.length > 0;
+}

package/esm/migrations/index.js

@@ -0,0 +1,2 @@
+export { generateMigrations } from './generate-migrations.js';
+export { migrate } from './migrate.js';

package/esm/migrations/migrate.js

@@ -0,0 +1,90 @@
+import { __decorate, __metadata } from "tslib";
+import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
+import { initDataProvider } from '../server/initDataProvider.js';
+import { doTransaction } from '../src/context.js';
+import { cast, isOfType } from '../src/isOfType.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is false.
+ * @param options.beforeMigration - (Optional) A callback function that is called before each migration is applied. Receives an object with the migration index.
+ * @param options.afterMigration - (Optional) A callback function that is called after each migration is applied. Receives an object with the migration index and the duration of the migration.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export async function migrate(options) {
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProvider(options.dataProvider);
+    const prev = remult.dataProvider;
+    remult.dataProvider = dataProvider;
+    try {
+        let VersionInfo = class VersionInfo extends IdEntity {
+            version = -1;
+        };
+        __decorate([
+            Fields.number(),
+            __metadata("design:type", Object)
+        ], VersionInfo.prototype, "version", void 0);
+        VersionInfo = __decorate([
+            Entity(migrationTableName)
+        ], VersionInfo);
+        const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
+        if (dataProvider.ensureSchema) {
+            await dataProvider.ensureSchema([
+                new Remult(dataProvider).repo(VersionInfo).metadata,
+            ]);
+        }
+        await doTransaction(remult, async (dp) => {
+            const repo = new Remult(dataProvider).repo(VersionInfo, dp);
+            let v = await repo.findFirst();
+            if (!v) {
+                v = repo.create();
+                v.version = -1;
+            }
+            for (const [stepText, action] of steps) {
+                const step = parseInt(stepText);
+                if (step < 0)
+                    throw new Error('Migration step number must be a non-negative integer');
+                if (v.version >= step)
+                    continue;
+                if (options.beforeMigration) {
+                    await options.beforeMigration({ index: step });
+                }
+                const startTime = Date.now();
+                console.info('Executing migration step ' + step);
+                console.time('Completed migration step ' + step);
+                try {
+                    const utils = {
+                        sql: async (sql) => {
+                            return await cast(dp, 'execute').execute(sql);
+                        },
+                    };
+                    await action(utils);
+                    if (options.afterMigration) {
+                        await options.afterMigration({
+                            index: step,
+                            duration: Date.now() - startTime,
+                        });
+                    }
+                    console.timeEnd('Completed migration step ' + step);
+                }
+                catch (err) {
+                    console.error('Failed to execute migration step ' + step);
+                    console.error(err);
+                    throw err;
+                }
+                v.version = step;
+                await v.save();
+            }
+        });
+    }
+    finally {
+        remult.dataProvider = prev;
+    }
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+}

package/esm/migrations/migration-types.js

@@ -0,0 +1,36 @@
+export class DefaultMigrationBuilder {
+    code;
+    wrapped;
+    constructor(code, wrapped) {
+        this.code = code;
+        this.wrapped = wrapped;
+    }
+    async createTable(meta) {
+        if (this.wrapped?.createTable) {
+            await this.wrapped.createTable(meta);
+        }
+        else
+            this.code.addComment('TODO: implement create table ' + meta.dbName);
+    }
+    async addColumn(meta, field) {
+        if (this.wrapped?.addColumn) {
+            await this.wrapped.addColumn(meta, field);
+        }
+        else
+            this.code.addComment('TODO: implement add column ' + meta.dbName + '.' + field.dbName);
+    }
+    async removeTable(entityDbName) {
+        if (this.wrapped?.removeTable) {
+            await this.wrapped.removeTable(entityDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove table ' + entityDbName);
+    }
+    async removeColumn(entityName, columnDbName) {
+        if (this.wrapped?.removeColumn) {
+            await this.wrapped.removeColumn(entityName, columnDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove column ' + entityName + '.' + columnDbName);
+    }
+}

package/esm/migrations/update-migrations-ts-file.js

@@ -0,0 +1,115 @@
+// consider replacing with https://www.npmjs.com/package/ts-morph
+export async function updateMigrationsFile(filePath, steps) {
+    let ts = await import('typescript');
+    //@ts-ignore
+    if (ts.default)
+        ts = ts.default;
+    const fs = await import('fs');
+    let maxStep = -1;
+    function buildSteps() {
+        return steps.map((step) => ts.factory.createPropertyAssignment(ts.factory.createIdentifier((++maxStep).toString()), ts.factory.createIdentifier(step)));
+    }
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '');
+    }
+    const importPath = 'remult/migrations';
+    const importName = 'Migrations';
+    // Load the file
+    const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
+    let migrationsExportFound = false;
+    // Find the "migrations" named export and add the new member
+    let updatedSourceFile = ts.transform(sourceFile, [
+        (context) => {
+            return (node) => {
+                const visitor = (node) => {
+                    if (ts.isVariableStatement(node) &&
+                        node.declarationList.declarations.length > 0) {
+                        const declaration = node.declarationList.declarations[0];
+                        if (ts.isIdentifier(declaration.name) &&
+                            declaration.name.text === 'migrations' &&
+                            declaration.initializer &&
+                            ts.isObjectLiteralExpression(declaration.initializer)) {
+                            migrationsExportFound = true;
+                            declaration.initializer.properties.forEach((property) => {
+                                if (ts.isPropertyAssignment(property)) {
+                                    if (ts.isNumericLiteral(property.name)) {
+                                        const step = parseInt(property.name.text);
+                                        if (step > maxStep) {
+                                            maxStep = step;
+                                        }
+                                    }
+                                }
+                            });
+                            let steps = buildSteps();
+                            // Found the "migrations" array
+                            // Update the initializer with the new steps
+                            const updatedInitializer = ts.factory.updateObjectLiteralExpression(declaration.initializer, [...declaration.initializer.properties, ...steps]);
+                            // Update the declaration with the new initializer
+                            const updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, undefined, declaration.type, // Preserve the original type annotation if present
+                            updatedInitializer);
+                            return ts.factory.updateVariableStatement(node, node.modifiers, ts.factory.updateVariableDeclarationList(node.declarationList, [
+                                updatedDeclaration,
+                            ]));
+                        }
+                    }
+                    return ts.visitEachChild(node, visitor, context);
+                };
+                return ts.visitNode(node, visitor);
+            };
+        },
+    ]).transformed[0];
+    if (!migrationsExportFound) {
+        let importFound = false;
+        // Check if the import statement already exists
+        sourceFile.statements.forEach((statement) => {
+            if (ts.isImportDeclaration(statement) &&
+                ts.isStringLiteral(statement.moduleSpecifier) &&
+                statement.moduleSpecifier.text === `${importPath}`) {
+                statement.importClause?.namedBindings?.forEachChild((namedBinding) => {
+                    if (ts.isImportSpecifier(namedBinding) &&
+                        namedBinding.name.text === importName) {
+                        importFound = true;
+                    }
+                });
+            }
+        });
+        // If the import statement doesn't exist, create it
+        if (!importFound) {
+            updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+                ts.factory.createExpressionStatement(ts.factory.createIdentifier(`import type { ${importName} } from '${importPath}'`)),
+                ...updatedSourceFile.statements,
+            ]);
+        }
+        // Create a new export for migrations if it doesn't exist
+        const newMigrationsExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration('migrations', undefined, // You can add a type annotation here if needed
+            ts.factory.createTypeReferenceNode(importName, undefined), ts.factory.createObjectLiteralExpression(buildSteps(), false)),
+        ], ts.NodeFlags.Const));
+        // Add the new export to the end of the file
+        updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+            ...updatedSourceFile.statements,
+            newMigrationsExport,
+        ]);
+    }
+    let code = ts.createPrinter().printFile(updatedSourceFile);
+    try {
+        let prettier;
+        try {
+            prettier = await import('prettier' + '');
+        }
+        catch (err) {
+            console.warn('error importing prettier,for better formatting run `npm i -D prettier`. Writing raw code to file.');
+        }
+        if (prettier) {
+            let options = await prettier.resolveConfig();
+            code = await prettier.format(code, {
+                ...options,
+                parser: 'typescript',
+            });
+        }
+    }
+    catch (err) {
+        console.log('error formatting code, writing raw code to file.');
+    }
+    fs.writeFileSync(filePath, code);
+}