remult 0.21.1 → 0.22.0

package/esm/myLog.js

@@ -1,5 +1,5 @@
 export async function writeToLog(what) {
-    if (typeof what !== "string")
+    if (typeof what !== 'string')
         what = JSON.stringify(what, undefined, 2);
-    (await (import('fs'))).appendFileSync('./tmp/test.log', what + '\n');
+    (await import('fs')).appendFileSync('./tmp/test.log', what + '\n');
 }

package/esm/postgres/postgres-data-provider.d.ts

@@ -26,11 +26,11 @@ export interface PostgresCommandSource {
 export declare function createPostgresConnection(options?: {
     connectionString?: string;
     sslInDev?: boolean;
-    configuration?: "heroku" | PoolConfig;
+    configuration?: 'heroku' | PoolConfig;
 }): Promise<SqlDatabase>;
 export declare function createPostgresDataProvider(options?: {
     connectionString?: string;
     sslInDev?: boolean;
-    configuration?: "heroku" | PoolConfig;
+    configuration?: 'heroku' | PoolConfig;
 }): Promise<SqlDatabase>;
 export declare function preparePostgresQueueStorage(sql: SqlDatabase): Promise<import("../server/expressBridge").EntityQueueStorage>;

package/esm/postgres/postgres-data-provider.js

@@ -1,6 +1,6 @@
 import { Pool } from 'pg';
 import { Remult } from '../src/context';
-import { PostgresSchemaBuilder } from './schema-builder';
+import { PostgresSchemaBuilder, } from './schema-builder';
 import { SqlDatabase } from '../src/data-providers/sql-database';
 export class PostgresDataProvider {
     constructor(pool) {
@@ -11,12 +11,11 @@ export class PostgresDataProvider {
         const sql = SqlDatabase.getDb(remult);
         const me = sql._getSourceSql();
         if (!me.pool) {
-            throw "the data provider is not a PostgresDataProvider";
+            throw 'the data provider is not a PostgresDataProvider';
         }
         return me.pool;
     }
-    async entityIsUsedForTheFirstTime(entity) {
-    }
+    async entityIsUsedForTheFirstTime(entity) { }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }
@@ -35,11 +34,13 @@ export class PostgresDataProvider {
             await action({
                 createCommand: () => new PostgresBridgeToSQLCommand(client),
                 entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
-                transaction: () => { throw "nested transactions not allowed"; },
+                transaction: () => {
+                    throw 'nested transactions not allowed';
+                },
                 getLimitSqlSyntax: this.getLimitSqlSyntax,
                 supportsJsonColumnType: this.supportsJsonColumnType,
                 //@ts-ignore
-                pool: client
+                pool: client,
             });
             await client.query('COMMIT');
         }
@@ -64,7 +65,9 @@ class PostgresBridgeToSQLCommand {
         return '$' + this.values.length;
     }
     execute(sql) {
-        return this.source.query(sql, this.values).then(r => new PostgresBridgeToSQLQueryResult(r));
+        return this.source
+            .query(sql, this.values)
+            .then((r) => new PostgresBridgeToSQLQueryResult(r));
     }
 }
 class PostgresBridgeToSQLQueryResult {
@@ -84,12 +87,14 @@ export async function createPostgresDataProvider(options) {
         options = {};
     let config = {};
     if (options.configuration)
-        if (options.configuration == "heroku") {
+        if (options.configuration == 'heroku') {
             config = {
                 connectionString: process.env.DATABASE_URL,
-                ssl: process.env.NODE_ENV !== "production" && !options.sslInDev ? false : {
-                    rejectUnauthorized: false
-                }
+                ssl: process.env.NODE_ENV !== 'production' && !options.sslInDev
+                    ? false
+                    : {
+                        rejectUnauthorized: false,
+                    },
             };
         }
         else
@@ -103,13 +108,14 @@ export async function createPostgresDataProvider(options) {
     }
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
-    remult.dataProvider = (db);
+    remult.dataProvider = db;
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
     let c = new Remult();
-    c.dataProvider = (sql);
-    let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
+    c.dataProvider = sql;
+    let JobsInQueueEntity = (await import('../server/expressBridge'))
+        .JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
     await sql.ensureSchema([e.metadata]);
     return new (await import('../server/expressBridge')).EntityQueueStorage(c.repo(JobsInQueueEntity));

package/esm/postgres/schema-builder.d.ts

@@ -9,7 +9,7 @@ export declare class PostgresSchemaBuilder {
     verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: (e: T) => FieldMetadata): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
     additionalWhere: string;
     constructor(pool: SqlDatabase, schema?: string);

package/esm/postgres/schema-builder.js

@@ -1,35 +1,38 @@
 import { allEntities } from '../src/context';
-import { dbNamesOf, isDbReadonly } from '../src/filter/filter-consumer-bridge-to-sql-request';
-import { RemultProxy } from '../src/remult-proxy';
+import { dbNamesOf, isDbReadonly, } from '../src/filter/filter-consumer-bridge-to-sql-request';
+import { remult as defaultRemult } from '../src/remult-proxy';
 import { isAutoIncrement } from '../src/remult3';
 import { ValueConverters } from '../src/valueConverters';
 export function postgresColumnSyntax(x, dbName) {
     let result = dbName;
     if (x.valueType == Number) {
         if (!x.valueConverter.fieldTypeInDb)
-            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+            result += ' numeric' + (x.allowNull ? '' : ' default 0 not null');
         else
-            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+            result +=
+                ' ' +
+                    x.valueConverter.fieldTypeInDb +
+                    (x.allowNull ? '' : ' default 0 not null');
     }
     else if (x.valueType == Date) {
         if (!x.valueConverter.fieldTypeInDb)
             if (x.valueConverter == ValueConverters.DateOnly)
-                result += " date";
+                result += ' date';
             else
-                result += " timestamp";
+                result += ' timestamp';
         else
-            result += " " + x.valueConverter.fieldTypeInDb;
+            result += ' ' + x.valueConverter.fieldTypeInDb;
     }
     else if (x.valueType == Boolean)
-        result += " boolean" + (x.allowNull ? "" : " default false not null");
+        result += ' boolean' + (x.allowNull ? '' : ' default false not null');
     else if (x.valueConverter.fieldTypeInDb) {
-        result += " " + x.valueConverter.fieldTypeInDb;
+        result += ' ' + x.valueConverter.fieldTypeInDb;
         if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
-            result += " default 0 not null";
+            result += ' default 0 not null';
         }
     }
     else
-        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+        result += ' varchar' + (x.allowNull ? '' : " default '' not null");
     return result;
 }
 export async function verifyStructureOfAllEntities(db, remult) {
@@ -40,12 +43,12 @@ export class PostgresSchemaBuilder {
         this.pool = pool;
         this.additionalWhere = '';
         if (schema) {
-            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
+            this.additionalWhere = " and table_schema='" + schema + "'";
         }
     }
     async verifyStructureOfAllEntities(remult) {
         if (!remult) {
-            remult = RemultProxy.defaultRemult;
+            remult = defaultRemult;
         }
         const completed = new Set();
         const entities = [];
@@ -71,14 +74,18 @@ export class PostgresSchemaBuilder {
                 }
             }
             catch (err) {
-                console.error("failed verify structure of " + e.$entityName + " ", err);
+                console.error('failed verify structure of ' + e.$entityName + ' ', err);
             }
         }
     }
     async createIfNotExist(entity) {
         var c = this.pool.createCommand();
         let e = await dbNamesOf(entity);
-        await c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.$entityName).toLowerCase()) + this.additionalWhere).then(async (r) => {
+        await c
+            .execute('select 1 from information_Schema.tables where table_name=' +
+            c.addParameterAndReturnSqlToken(e.$entityName.toLowerCase()) +
+            this.additionalWhere)
+            .then(async (r) => {
             if (r.rows.length == 0) {
                 let result = '';
                 for (const x of entity.fields) {
@@ -109,9 +116,9 @@ 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 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.$entityName).toLocaleLowerCase())} and column_name=${cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase())}` + this.additionalWhere)).rows.length == 0) {
+            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)
                     console.info(sql);
@@ -126,9 +133,9 @@ 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 
-        WHERE table_name=${cmd.addParameterAndReturnSqlToken((e.$entityName).toLocaleLowerCase())} ` + this.additionalWhere)).rows.map(x => x.column_name.toLocaleLowerCase());
+            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)) {
                     let colName = e.$dbNameOf(col).toLocaleLowerCase();

package/esm/remult-express.js

@@ -13,8 +13,8 @@ export function remultExpress(options) {
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
     const server = createRemultServer(options, {
-        buildGenericRequestInfo: req => req,
-        getRequestBody: async (req) => req.body
+        buildGenericRequestInfo: (req) => req,
+        getRequestBody: async (req) => req.body,
     });
     server.registerRouter(app);
     return Object.assign(app, {

package/esm/remult-fastify.js

@@ -18,19 +18,19 @@ export function remultFastify(options) {
                 },
                 writeHead(status, headers) {
                     res.raw.writeHead(status, headers);
-                }
+                },
             };
             Object.assign(req, {
                 on(event, listener) {
                     req.raw.on(event, listener);
-                }
+                },
             });
             handler(req, myRes, () => { });
         };
         return response;
     }
     const api = createRemultServer(options, {
-        buildGenericRequestInfo: req => req,
+        buildGenericRequestInfo: (req) => req,
         getRequestBody: async (req) => req.body,
     });
     const pluginFunction = async (instance, op) => {
@@ -45,10 +45,12 @@ export function remultFastify(options) {
                     get(handler) {
                         instance.get(path, fastifyHandler(handler));
                         return r;
-                    }, post(handler) {
+                    },
+                    post(handler) {
                         instance.post(path, fastifyHandler(handler));
                         return r;
-                    }, put(handler) {
+                    },
+                    put(handler) {
                         instance.put(path, fastifyHandler(handler));
                         return r;
                     },
@@ -59,8 +61,8 @@ export function remultFastify(options) {
         api.registerRouter(fastifyRouter);
     };
     return Object.assign(pluginFunction, {
-        getRemult: x => api.getRemult(x),
-        openApiDoc: x => api.openApiDoc(x),
+        getRemult: (x) => api.getRemult(x),
+        openApiDoc: (x) => api.openApiDoc(x),
         withRemult: (req, what) => api.withRemultPromise(req, what),
     });
 }

package/esm/remult-fresh.d.ts

@@ -1,4 +1,4 @@
-import { RemultServerOptions, RemultServerCore } from "./server/expressBridge";
+import { RemultServerOptions, RemultServerCore } from './server/expressBridge';
 export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
 export interface RemultFresh extends RemultServerCore<FreshRequest> {
     handle(req: FreshRequest, ctx: FreshContext): Promise<any>;

package/esm/remult-fresh.js

@@ -1,12 +1,12 @@
-import { createRemultServerCore } from "./server/expressBridge";
+import { createRemultServerCore, } from './server/expressBridge';
 export function remultFresh(options, response) {
     const server = createRemultServerCore(options, {
-        buildGenericRequestInfo: r => r,
-        getRequestBody: req => req.json()
+        buildGenericRequestInfo: (r) => r,
+        getRequestBody: (req) => req.json(),
     });
     return {
-        getRemult: r => server.getRemult(r),
-        openApiDoc: x => server.openApiDoc(x),
+        getRemult: (r) => server.getRemult(r),
+        openApiDoc: (x) => server.openApiDoc(x),
         handle: async (req, ctx) => {
             let init = {};
             const res = await server.handle(req);
@@ -21,9 +21,6 @@ export function remultFresh(options, response) {
             else {
                 return ctx.next();
             }
-            ;
         },
     };
 }
-;
-;

package/esm/remult-knex/index.d.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
-import { Remult } from "../src/context";
-import { EntityFilter, EntityMetadata, RepositoryOverloads } from "../src/remult3";
+import { Remult } from '../src/context';
+import { EntityFilter, EntityMetadata, RepositoryOverloads } from '../src/remult3';
 import { DataProvider, EntityDataProvider } from '../src/data-interfaces';
 import { FieldMetadata } from '../src/column-interfaces';
 export declare class KnexDataProvider implements DataProvider {
@@ -11,7 +11,7 @@ export declare class KnexDataProvider implements DataProvider {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
     static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
-    supportsRawFilter?: boolean;
+    isProxy?: boolean;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
 }
 export declare type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
@@ -20,7 +20,7 @@ export declare class KnexSchemaBuilder {
     verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: ((e: T) => FieldMetadata)): Promise<void>;
+    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: (e: T) => FieldMetadata): Promise<void>;
     verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
     additionalWhere: string;
     constructor(knex: Knex);