remult 0.22.5 → 0.22.6-exp.2

package/esm/graphql.js

@@ -87,7 +87,7 @@ export function remultGraphql(options) {
             }
         }
         if (whereType === 'String') {
-            for (const operator of ['st']) {
+            for (const operator of ['contains']) {
                 const field = {
                     key: operator,
                     value: whereType,
@@ -208,16 +208,16 @@ export function remultGraphql(options) {
                 {
                     key: 'limit',
                     value: 'Int',
-                    comment: `
-For **page by page** pagination.
-Limit the number of result. 
+                    comment: `
+For **page by page** pagination.
+Limit the number of result. 
 _Side note: \`Math.ceil(totalCount / limit)\` to determine how many pages there are._`,
                 },
                 {
                     key: 'page',
                     value: 'Int',
-                    comment: `
-For **page by page** pagination.
+                    comment: `
+For **page by page** pagination.
 Select a dedicated page.`,
                 },
                 {
@@ -235,26 +235,26 @@ Select a dedicated page.`,
                 queryArgsConnection.push({
                     key: 'first',
                     value: 'Int',
-                    comment: `
-        For **forward cursor** pagination
+                    comment: `
+        For **forward cursor** pagination
         Takes the \`first\`: \`n\` elements from the list.`,
                 }, {
                     key: 'after',
                     value: 'String',
-                    comment: `
-        For **forward cursor** pagination
+                    comment: `
+        For **forward cursor** pagination
         \`after\` this \`cursor\`.`,
                 }, {
                     key: 'last',
                     value: 'Int',
-                    comment: `
-        For **backward cursor** pagination
+                    comment: `
+        For **backward cursor** pagination
         Takes the \`last\`: \`n\` elements from the list.`,
                 }, {
                     key: 'before',
                     value: 'String',
-                    comment: `
-        For **backward cursor** pagination
+                    comment: `
+        For **backward cursor** pagination
         \`before\` this \`cursor\`.`,
                 });
             }
@@ -668,7 +668,7 @@ Select a dedicated page.`,
                 : ``;
             return `${type}${orderByStr}${whereTypeStr}${whereTypeSubFieldsStr}`;
         })
-            .join(`\n\n`)}
+            .join(`\n\n`)}
 `,
     };
 }
@@ -690,12 +690,12 @@ function blockFormat(obj) {
     if (obj.data.length === 0) {
         return ``;
     }
-    const str = `${obj.prefix} {
-  ${obj.data.join('\n  ')}
+    const str = `${obj.prefix} {
+  ${obj.data.join('\n  ')}
 }`;
-    let commentsStr = `"""
-${obj.comment}
-"""
+    let commentsStr = `"""
+${obj.comment}
+"""
 `;
     if (_removeComments) {
         commentsStr = ``;
@@ -706,16 +706,16 @@ function argsFormat(args) {
     if (args) {
         return `(${args
             .map((arg) => {
-            let strComment = `
-    """
-    ${arg.comment}
-    """
+            let strComment = `
+    """
+    ${arg.comment}
+    """
 `;
             if (_removeComments || !arg.comment) {
                 strComment = ``;
             }
             if (strComment) {
-                return `${strComment}    ${arg.key}: ${arg.value}
+                return `${strComment}    ${arg.key}: ${arg.value}
   `;
             }
             return `${arg.key}: ${arg.value}`;
@@ -726,9 +726,9 @@ function argsFormat(args) {
 }
 function fieldFormat(field) {
     // First, the comment
-    let strComment = `"""
-  ${field.comment}
-  """
+    let strComment = `"""
+  ${field.comment}
+  """
 `;
     if (_removeComments || !field.comment) {
         strComment = ``;
@@ -801,6 +801,7 @@ export function translateWhereToRestBody(fields, { where }) {
             }
             tr('nin', (x) => (result[field.key + '.ne'] = x));
             tr('eq', (x) => (result[field.key] = x));
+            tr('contains', (x) => (result[field.key + '.contains'] = x));
         }
     }
     if (where.OR) {

package/esm/internals.js

@@ -0,0 +1,7 @@
+import { remultStatic } from './src/remult-static.js';
+export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
+export { getEntitySettings } from './src/remult3/getEntityRef.js';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
+export const actionInfo = remultStatic.actionInfo;
+export { flags } from './src/remult3/remult3.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 { initDataProviderOrJson } from '../server/initDataProviderOrJson.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 initDataProviderOrJson(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,85 @@
+import { Entity, IdEntity, Fields, remult, Remult, describeClass, } from '../index.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson.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 initDataProviderOrJson(options.dataProvider);
+    const prev = remult.dataProvider;
+    remult.dataProvider = dataProvider;
+    try {
+        class VersionInfo extends IdEntity {
+            version = -1;
+        }
+        describeClass(VersionInfo, Entity(migrationTableName), {
+            version: Fields.integer(),
+        });
+        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);
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/postgres/schema-builder.js

@@ -116,8 +116,8 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             const colName = e.$dbNameOf(c(entity));
-            if ((await cmd.execute(`select 1   
-        FROM information_schema.columns 
+            if ((await cmd.execute(`select 1   
+        FROM information_schema.columns 
         WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken(colName.toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
                 let sql = `alter table ${e.$entityName} add column ${postgresColumnSyntax(c(entity), colName)}`;
                 if (PostgresSchemaBuilder.logToConsole)
@@ -133,8 +133,8 @@ export class PostgresSchemaBuilder {
         try {
             let cmd = this.pool.createCommand();
             let e = await dbNamesOf(entity);
-            let cols = (await cmd.execute(`select column_name   
-        FROM information_schema.columns 
+            let cols = (await cmd.execute(`select column_name   
+        FROM information_schema.columns 
         WHERE table_name=${cmd.addParameterAndReturnSqlToken(e.$entityName.toLocaleLowerCase())} ` + this.additionalWhere)).rows.map((x) => x.column_name.toLocaleLowerCase());
             for (const col of entity.fields) {
                 if (!isDbReadonly(col, e)) {

package/esm/remult-better-sqlite3.js

@@ -0,0 +1,47 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class BetterSqlite3DataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BetterSqlite3Command(db), async () => { db.close(); });
+    }
+}
+class BetterSqlite3Command {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.prepare(sql);
+        if (s.reader) {
+            return new BetterSqlite3SqlResult(s.all(this.values));
+        }
+        else {
+            const result = s.run(this.values);
+            return new BetterSqlite3SqlResult([]);
+        }
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key.substring(1)] = (val);
+        return key;
+    }
+}
+export class BetterSqlite3SqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-bun-sqlite.js

@@ -0,0 +1,41 @@
+import { SqliteCoreDataProvider } from "./remult-sqlite-core.js";
+export class BunSqliteDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BunSqliteCommand(db), async () => { db.close(); });
+    }
+}
+class BunSqliteCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.query(sql);
+        return new BunSqliteSqlResult(s.all(this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key] = (val);
+        return key;
+    }
+}
+class BunSqliteSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}