remult 0.22.7-exp.0 → 0.22.7

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

@@ -1,122 +1,126 @@
-import { Pool } from 'pg';
-import { Remult } from '../src/context';
-import { SqlDatabase } from '../src/data-providers/sql-database';
-import { PostgresSchemaBuilder } from './schema-builder';
-export class PostgresDataProvider {
-    constructor(pool) {
-        this.pool = pool;
-        this.supportsJsonColumnType = true;
-    }
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
-        if (!me.pool) {
-            throw 'the data provider is not a PostgresDataProvider';
-        }
-        return me.pool;
-    }
-    async entityIsUsedForTheFirstTime(entity) { }
-    getLimitSqlSyntax(limit, offset) {
-        return ' limit ' + limit + ' offset ' + offset;
-    }
-    createCommand() {
-        return new PostgresBridgeToSQLCommand(this.pool);
-    }
-    async ensureSchema(entities) {
-        var db = new SqlDatabase(this);
-        var sb = new PostgresSchemaBuilder(db);
-        await sb.ensureSchema(entities);
-    }
-    async transaction(action) {
-        let client = await this.pool.connect();
-        try {
-            await client.query('BEGIN');
-            await action({
-                createCommand: () => new PostgresBridgeToSQLCommand(client),
-                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
-                transaction: () => {
-                    throw 'nested transactions not allowed';
-                },
-                getLimitSqlSyntax: this.getLimitSqlSyntax,
-                supportsJsonColumnType: this.supportsJsonColumnType,
-                //@ts-ignore
-                pool: client,
-            });
-            await client.query('COMMIT');
-        }
-        catch (err) {
-            await client.query('ROLLBACK');
-            throw err;
-        }
-        finally {
-            await client.release();
-        }
-    }
-}
-class PostgresBridgeToSQLCommand {
-    constructor(source) {
-        this.source = source;
-        this.values = [];
-    }
-    addParameterAndReturnSqlToken(val) {
-        if (Array.isArray(val))
-            val = JSON.stringify(val);
-        this.values.push(val);
-        return '$' + this.values.length;
-    }
-    execute(sql) {
-        return this.source
-            .query(sql, this.values)
-            .then((r) => new PostgresBridgeToSQLQueryResult(r));
-    }
-}
-class PostgresBridgeToSQLQueryResult {
-    constructor(r) {
-        this.r = r;
-        this.rows = r.rows;
-    }
-    getColumnKeyInResultForIndexInSelect(index) {
-        return this.r.fields[index].name;
-    }
-}
-export async function createPostgresConnection(options) {
-    return createPostgresDataProvider(options);
-}
-export async function createPostgresDataProvider(options) {
-    if (!options)
-        options = {};
-    let config = {};
-    if (options.configuration)
-        if (options.configuration == 'heroku') {
-            config = {
-                connectionString: process.env.DATABASE_URL,
-                ssl: process.env.NODE_ENV !== 'production' && !options.sslInDev
-                    ? false
-                    : {
-                        rejectUnauthorized: false,
-                    },
-            };
-        }
-        else
-            config = options.configuration;
-    else {
-        if (!options.connectionString)
-            options.connectionString = process.env.DATABASE_URL;
-    }
-    if (!config.connectionString && options.connectionString) {
-        config.connectionString = options.connectionString;
-    }
-    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
-    let remult = new Remult();
-    remult.dataProvider = db;
-    return db;
-}
-export async function preparePostgresQueueStorage(sql) {
-    let c = new Remult();
-    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));
-}
+import { Pool } from 'pg';
+import { Remult } from '../src/context';
+import { SqlDatabase } from '../src/data-providers/sql-database';
+import { PostgresSchemaBuilder } from './schema-builder';
+export class PostgresDataProvider {
+    pool;
+    supportsJsonColumnType = true;
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.pool) {
+            throw 'the data provider is not a PostgresDataProvider';
+        }
+        return me.pool;
+    }
+    async entityIsUsedForTheFirstTime(entity) { }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    createCommand() {
+        return new PostgresBridgeToSQLCommand(this.pool);
+    }
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async ensureSchema(entities) {
+        var db = new SqlDatabase(this);
+        var sb = new PostgresSchemaBuilder(db);
+        await sb.ensureSchema(entities);
+    }
+    async transaction(action) {
+        let client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            await action({
+                createCommand: () => new PostgresBridgeToSQLCommand(client),
+                entityIsUsedForTheFirstTime: this.entityIsUsedForTheFirstTime,
+                transaction: () => {
+                    throw 'nested transactions not allowed';
+                },
+                getLimitSqlSyntax: this.getLimitSqlSyntax,
+                supportsJsonColumnType: this.supportsJsonColumnType,
+                //@ts-ignore
+                pool: client,
+            });
+            await client.query('COMMIT');
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            await client.release();
+        }
+    }
+}
+class PostgresBridgeToSQLCommand {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    values = [];
+    addParameterAndReturnSqlToken(val) {
+        if (Array.isArray(val))
+            val = JSON.stringify(val);
+        this.values.push(val);
+        return '$' + this.values.length;
+    }
+    execute(sql) {
+        return this.source
+            .query(sql, this.values)
+            .then((r) => new PostgresBridgeToSQLQueryResult(r));
+    }
+}
+class PostgresBridgeToSQLQueryResult {
+    r;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.r.fields[index].name;
+    }
+    constructor(r) {
+        this.r = r;
+        this.rows = r.rows;
+    }
+    rows;
+}
+export async function createPostgresConnection(options) {
+    return createPostgresDataProvider(options);
+}
+export async function createPostgresDataProvider(options) {
+    if (!options)
+        options = {};
+    let config = {};
+    if (options.configuration)
+        if (options.configuration == 'heroku') {
+            config = {
+                connectionString: process.env.DATABASE_URL,
+                ssl: process.env.NODE_ENV !== 'production' && !options.sslInDev
+                    ? false
+                    : {
+                        rejectUnauthorized: false,
+                    },
+            };
+        }
+        else
+            config = options.configuration;
+    else {
+        if (!options.connectionString)
+            options.connectionString = process.env.DATABASE_URL;
+    }
+    if (!config.connectionString && options.connectionString) {
+        config.connectionString = options.connectionString;
+    }
+    const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
+    let remult = new Remult();
+    remult.dataProvider = db;
+    return db;
+}
+export async function preparePostgresQueueStorage(sql) {
+    let c = new Remult();
+    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

@@ -1,19 +1,19 @@
-import type { FieldMetadata } from '../src/column-interfaces';
-import type { Remult } from '../src/context';
-import type { SqlDatabase } from '../src/data-providers/sql-database';
-import type { EntityMetadata } from '../src/remult3/remult3';
-export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
-export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
-export declare class PostgresSchemaBuilder {
-    private pool;
-    private removeQuotes;
-    private whereTableAndSchema;
-    private schemaAndName;
-    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>;
-    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
-    specifiedSchema: string;
-    constructor(pool: SqlDatabase, schema?: string);
-}
+import type { FieldMetadata } from '../src/column-interfaces';
+import type { Remult } from '../src/context';
+import type { SqlDatabase } from '../src/data-providers/sql-database';
+import type { EntityMetadata } from '../src/remult3/remult3';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;
+export declare function verifyStructureOfAllEntities(db: SqlDatabase, remult: Remult): Promise<void>;
+export declare class PostgresSchemaBuilder {
+    private pool;
+    private removeQuotes;
+    private whereTableAndSchema;
+    private schemaAndName;
+    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>;
+    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
+    specifiedSchema: string;
+    constructor(pool: SqlDatabase, schema?: string);
+}