nodecommons-esm-database 0.0.2

package/dist/interfaces/icommons-credentials.mjs

@@ -0,0 +1,17 @@
+import { commonsTypeHasPropertyString, commonsTypeHasPropertyStringOrUndefined, commonsTypeHasPropertyNumberOrUndefined } from 'tscommons-esm-core';
+export function isICommonsCredentials(test) {
+    if (!commonsTypeHasPropertyString(test, 'name'))
+        return false;
+    if (!commonsTypeHasPropertyStringOrUndefined(test, 'user'))
+        return false;
+    if (!commonsTypeHasPropertyStringOrUndefined(test, 'password'))
+        return false;
+    if (!commonsTypeHasPropertyStringOrUndefined(test, 'host'))
+        return false;
+    if (!commonsTypeHasPropertyNumberOrUndefined(test, 'port'))
+        return false;
+    if (!commonsTypeHasPropertyStringOrUndefined(test, 'authSource'))
+        return false;
+    return true;
+}
+//# sourceMappingURL=icommons-credentials.mjs.map

package/dist/interfaces/icommons-credentials.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"icommons-credentials.mjs","sourceRoot":"","sources":["../../src/interfaces/icommons-credentials.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,uCAAuC,EACvC,uCAAuC,EACxC,MAAM,oBAAoB,CAAC;AAW5B,MAAM,UAAU,qBAAqB,CAAC,IAAS;IAC9C,IAAI,CAAC,4BAA4B,CAAC,IAAI,EAAE,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,CAAC,uCAAuC,CAAC,IAAI,EAAE,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACzE,IAAI,CAAC,uCAAuC,CAAC,IAAI,EAAE,UAAU,CAAC;QAAE,OAAO,KAAK,CAAC;IAC7E,IAAI,CAAC,uCAAuC,CAAC,IAAI,EAAE,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACzE,IAAI,CAAC,uCAAuC,CAAC,IAAI,EAAE,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACzE,IAAI,CAAC,uCAAuC,CAAC,IAAI,EAAE,YAAY,CAAC;QAAE,OAAO,KAAK,CAAC;IAE/E,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/services/commons-nosql-database.service.d.mts

@@ -0,0 +1,8 @@
+import { ICommonsCredentials } from '../interfaces/icommons-credentials.mjs';
+export type TQueryParams = {
+    [name: string]: any;
+};
+export declare abstract class CommonsNosqlDatabaseService<CredentialsI extends ICommonsCredentials> {
+    protected credentials: CredentialsI;
+    constructor(credentials: CredentialsI);
+}

package/dist/services/commons-nosql-database.service.mjs

@@ -0,0 +1,7 @@
+export class CommonsNosqlDatabaseService {
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+}
+//# sourceMappingURL=commons-nosql-database.service.mjs.map

package/dist/services/commons-nosql-database.service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commons-nosql-database.service.mjs","sourceRoot":"","sources":["../../src/services/commons-nosql-database.service.mts"],"names":[],"mappings":"AAMA,MAAM,OAAgB,2BAA2B;IAEpC;IADZ,YACY,WAAyB;QAAzB,gBAAW,GAAX,WAAW,CAAc;IAClC,CAAC;CACJ"}

package/dist/services/commons-sql-database.service.d.mts

@@ -0,0 +1,65 @@
+import { TPropertyObject } from 'tscommons-esm-core';
+import { CommonsDatabaseType } from '../classes/commons-database-type.mjs';
+import { CommonsDatabaseParam } from '../classes/commons-database-param.mjs';
+import { CommonsDatabase } from '../helpers/commons-database.mjs';
+import { ICommonsCredentials } from '../interfaces/icommons-credentials.mjs';
+import { TCommonsDatabaseParams } from '../types/tcommons-database-params.mjs';
+import { TCommonsDatabaseTypes } from '../types/tcommons-database-types.mjs';
+import { ECommonsDatabaseEngine } from '../enums/ecommons-database-engine.mjs';
+import { ECommonsDatabaseReferentialAction } from '../enums/ecommons-database-referential-action.mjs';
+export declare function commonsDatabaseAssertField(field: string): string;
+export declare abstract class CommonsSqlDatabaseService<CredentialsI extends ICommonsCredentials> extends CommonsDatabase {
+    protected credentials: CredentialsI;
+    private preprepared;
+    private transactionState;
+    constructor(engine: ECommonsDatabaseEngine, credentials: CredentialsI);
+    abstract connect(): Promise<void>;
+    preprepare(name: string, sql: string, params?: TCommonsDatabaseTypes, // this is deliberate, we don't have the param values yet
+    results?: TCommonsDatabaseTypes): void;
+    abstract doesTableExist(name: string): Promise<boolean>;
+    protected abstract internalSelect(sql: string, params?: TPropertyObject): Promise<TPropertyObject[]>;
+    protected abstract internalNone(sql: string, params?: TPropertyObject): Promise<void>;
+    protected abstract internalTransactionBegin(): Promise<void>;
+    protected abstract internalTransactionCommit(): Promise<void>;
+    protected abstract internalTransactionRollback(): Promise<void>;
+    transactionClaim(): Promise<boolean>;
+    transactionCommit(): Promise<void>;
+    transactionRollback(): Promise<void>;
+    private buildParams;
+    queryParams<T extends TPropertyObject>(sql: string, params?: TCommonsDatabaseParams, results?: TCommonsDatabaseTypes): Promise<T[]>;
+    noneParams(sql: string, params?: TCommonsDatabaseParams): Promise<void>;
+    queryParamsSingle<T extends TPropertyObject>(sql: string, params?: TCommonsDatabaseParams, results?: TCommonsDatabaseTypes): Promise<T | undefined>;
+    queryParamsList<U>(sql: string, params?: TCommonsDatabaseParams, field?: string, type?: CommonsDatabaseType): Promise<U[]>;
+    queryParamsValue<U>(sql: string, params?: TCommonsDatabaseParams, field?: string, type?: CommonsDatabaseType, allowNone?: boolean): Promise<U | undefined>;
+    queryParamsValueNoNone<U>(sql: string, params?: TCommonsDatabaseParams, field?: string, type?: CommonsDatabaseType): Promise<U>;
+    private buildPrepreparedParams;
+    executeParams<T extends TPropertyObject>(name: string, values?: TPropertyObject): Promise<T[]>;
+    executeParamsSingle<T extends TPropertyObject>(name: string, values?: TPropertyObject): Promise<T | undefined>;
+    executeParamsList<U>(name: string, values?: TPropertyObject): Promise<U[]>;
+    executeParamsValue<U>(name: string, values?: TPropertyObject, allowNone?: boolean): Promise<U | undefined>;
+    executeParamsValueNoNone<U>(name: string, values?: TPropertyObject): Promise<U>;
+    private generateCreateTableSql;
+    createTable(table: string, structure: TCommonsDatabaseTypes, ifNotExists?: boolean): Promise<void>;
+    dropTable(table: string, structure: TCommonsDatabaseTypes, ifExists?: boolean): Promise<void>;
+    createView(table: string, name: string, sql: string, ifNotExists?: boolean): Promise<void>;
+    dropView(table: string, name: string, ifExists?: boolean): Promise<void>;
+    createForeignKey(table: string, destTable: string, field: string, destId: string, onDelete?: ECommonsDatabaseReferentialAction, onUpdate?: ECommonsDatabaseReferentialAction, constraintName?: string): Promise<void>;
+    generateCreateForeignKeySql(table: string, destTable: string, field: string, destId: string, onDelete?: ECommonsDatabaseReferentialAction, onUpdate?: ECommonsDatabaseReferentialAction, constraintName?: string): string;
+    createUniqueKey(table: string, fields: string[], constraintName?: string): Promise<void>;
+    generateCreateUniqueKeySql(table: string, fields: string[], constraintName?: string): string;
+    createIndexKey(table: string, fields: string[], constraintName?: string): Promise<void>;
+    generateCreateIndexKeySql(table: string, fields: string[], indexName?: string): string;
+    private insertOrReplaceRow;
+    insertRow(table: string, values: {
+        [key: string]: CommonsDatabaseParam;
+    }, autoinc?: string): Promise<number | void>;
+    upsertRow(table: string, values: {
+        [key: string]: CommonsDatabaseParam;
+    }, conflictFields?: string[], autoinc?: string): Promise<number | void>;
+    private buildClause;
+    updateRowsByConditions(table: string, values: TCommonsDatabaseParams, conditions: TCommonsDatabaseParams, singular?: boolean): Promise<void>;
+    deleteRowsByConditions(table: string, conditions: TCommonsDatabaseParams, singular?: boolean): Promise<void>;
+    selectRowsByConditions<T extends TPropertyObject>(table: string, fields: TCommonsDatabaseTypes, conditions: TCommonsDatabaseParams): Promise<T[]>;
+    countRowsByConditions(table: string, conditions: TCommonsDatabaseParams): Promise<number>;
+    doesRowExistByConditions(table: string, conditions: TCommonsDatabaseParams): Promise<boolean>;
+}

package/dist/services/commons-sql-database.service.mjs

@@ -0,0 +1,538 @@
+import { commonsTypeIsNumber, commonsObjectIsEmpty, commonsObjectMapObject } from 'tscommons-esm-core';
+import { CommonsDatabaseType } from '../classes/commons-database-type.mjs';
+import { CommonsDatabaseParam } from '../classes/commons-database-param.mjs';
+import { CommonsDatabaseTypeEnum } from '../classes/commons-database-type-enum.mjs';
+import { CommonsDatabaseTypeSerialId } from '../classes/commons-database-type-serial-id.mjs';
+import { CommonsDatabaseTypeInt } from '../classes/commons-database-type-int.mjs';
+import { CommonsDatabaseTypeNumber } from '../classes/commons-database-type-number.mjs';
+import { CommonsDatabase } from '../helpers/commons-database.mjs';
+import { ECommonsDatabaseEngine } from '../enums/ecommons-database-engine.mjs';
+import { ECommonsDatabaseReferentialAction } from '../enums/ecommons-database-referential-action.mjs';
+import { ECommonsDatabaseInsertMethod } from '../enums/ecommons-database-insert-method.mjs';
+import { ECommonsDatabaseTypeNull } from '../enums/ecommons-database-type-null.mjs';
+import { ECommonsDatabaseTypeSigned } from '../enums/ecommons-database-type-signed.mjs';
+var ETransactionState;
+(function (ETransactionState) {
+    ETransactionState[ETransactionState["FREE"] = 0] = "FREE";
+    ETransactionState[ETransactionState["PENDING"] = 1] = "PENDING";
+    ETransactionState[ETransactionState["RUNNING"] = 2] = "RUNNING";
+})(ETransactionState || (ETransactionState = {}));
+function strongTypeResult(value, type, engine) {
+    if (value !== undefined)
+        value = type.processOut(value, engine);
+    type.assert(value);
+    return value;
+}
+function singleRow(rows) {
+    if (rows.length === 0)
+        return undefined;
+    if (rows.length > 1)
+        throw new Error('execute/queryParamsSingle didn\'t return one exact row');
+    return rows[0];
+}
+function singleList(rows) {
+    return rows
+        .map((row) => {
+        const keys = Object.keys(row);
+        if (keys.length !== 1)
+            throw new Error('execute/queryParamsList returned more than one column');
+        return row[keys[0]]; // assume correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+    });
+}
+export function commonsDatabaseAssertField(field) {
+    if (/[[\];/\\?'"\r\n\t\0`]/.test(field))
+        throw new Error(`Condition field contains an invalid character: ${field}`);
+    return field;
+}
+export class CommonsSqlDatabaseService extends CommonsDatabase {
+    credentials;
+    preprepared = new Map();
+    transactionState = ETransactionState.FREE;
+    constructor(engine, credentials) {
+        super(engine);
+        this.credentials = credentials;
+    }
+    preprepare(name, sql, params, // this is deliberate, we don't have the param values yet
+    results) {
+        if (this.preprepared.has(name))
+            throw new Error('Duplicate name for preprepared statement');
+        const prep = {
+            sql: sql,
+            isSelect: /^SELECT /i.test(sql),
+            params: params,
+            results: results
+        };
+        this.preprepared.set(name, prep);
+    }
+    async transactionClaim() {
+        if (this.transactionState !== ETransactionState.FREE)
+            return false;
+        this.transactionState = ETransactionState.PENDING;
+        try {
+            await this.internalTransactionBegin();
+            if (this.transactionState !== ETransactionState.PENDING)
+                throw new Error('Transaction clash');
+            this.transactionState = ETransactionState.RUNNING;
+            return true;
+        }
+        catch (e) {
+            console.log(e);
+            this.transactionState = ETransactionState.FREE;
+            return false;
+        }
+    }
+    async transactionCommit() {
+        if (this.transactionState !== ETransactionState.RUNNING)
+            throw new Error('No transaction is running');
+        try {
+            await this.internalTransactionCommit();
+        }
+        catch (e) {
+            console.log(e);
+        }
+        finally {
+            this.transactionState = ETransactionState.FREE;
+        }
+    }
+    async transactionRollback() {
+        if (this.transactionState !== ETransactionState.RUNNING)
+            throw new Error('No transaction is running');
+        try {
+            await this.internalTransactionRollback();
+        }
+        catch (e) {
+            console.log(e);
+        }
+        finally {
+            this.transactionState = ETransactionState.FREE;
+        }
+    }
+    buildParams(params) {
+        return commonsObjectMapObject(params, (object, _key) => {
+            const typecast = object;
+            typecast.process(this.getEngine());
+            return typecast.getValue();
+        });
+    }
+    async queryParams(sql, params, results) {
+        let internalData;
+        if (params)
+            internalData = this.buildParams(params);
+        const data = await this.internalSelect(sql.trim(), internalData);
+        if (data.length === 0)
+            return [];
+        if (!results)
+            return data; // can't check if not result definition to check against
+        const typecasted = [];
+        for (const row of data) {
+            const resultsKeys = Object.keys(results);
+            const rowKeys = Object.keys(row);
+            if (resultsKeys.length !== rowKeys.length)
+                throw new Error('Supplied result types is not the same length as actual results');
+            const extra = rowKeys
+                .filter((field) => !resultsKeys.includes(field));
+            if (extra.length > 0)
+                throw new Error('Returned row result field does not exist in the defined result structure');
+            const missing = resultsKeys
+                .filter((field) => !rowKeys.includes(field));
+            if (missing.length > 0)
+                throw new Error('Defined result structure field is missing from the returned row results');
+            const typecast = commonsObjectMapObject(row, (value, field) => strongTypeResult(value, results[field], this.getEngine()));
+            typecasted.push(typecast);
+        }
+        return typecasted; // assume correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+    }
+    async noneParams(sql, params) {
+        let internalData;
+        if (params)
+            internalData = this.buildParams(params);
+        await this.internalNone(sql.trim(), internalData);
+    }
+    async queryParamsSingle(sql, params, results) {
+        const rows = await this.queryParams(sql, params, results);
+        return singleRow(rows);
+    }
+    async queryParamsList(sql, params, field, type) {
+        // can use TPropertyObject as we don't care about the mid-way structure types, only the end generic result.
+        // can assume the mid-way is correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+        let results;
+        if (field && type) {
+            results = {};
+            results[field] = type;
+        }
+        const rows = await this.queryParams(sql, params, results);
+        return singleList(rows);
+    }
+    async queryParamsValue(sql, params, field, type, allowNone = false) {
+        // can use TPropertyObject as we don't care about the mid-way structure types, only the end generic result.
+        // can assume the mid-way is correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+        const rows = await this.queryParamsList(sql, params, field, type);
+        if (rows.length === 0) {
+            if (allowNone)
+                return undefined;
+            throw new Error('queryParamsValue did not return a result and allowNone is false');
+        }
+        if (rows.length !== 1)
+            throw new Error('queryParamsValue returned more than one row');
+        return rows[0];
+    }
+    // helper method to avoid |undefined
+    async queryParamsValueNoNone(sql, params, field, type) {
+        return (await this.queryParamsValue(sql, params, field, type));
+    }
+    buildPrepreparedParams(values, types // intentional
+    ) {
+        const params = {};
+        for (const field of Object.keys(values)) {
+            params[field] = new CommonsDatabaseParam(values[field], types[field]);
+            params[field].process(this.getEngine());
+        }
+        return params;
+    }
+    async executeParams(name, values) {
+        if (!this.preprepared.has(name))
+            throw new Error('Preprepared statement does not exist');
+        const preprepared = this.preprepared.get(name);
+        let params;
+        if (values && preprepared.params) {
+            params = this.buildPrepreparedParams(values, preprepared.params);
+        }
+        return await this.queryParams(preprepared.sql, params, preprepared.results);
+    }
+    async executeParamsSingle(name, values) {
+        const rows = await this.executeParams(name, values);
+        return singleRow(rows);
+    }
+    async executeParamsList(name, values) {
+        // can use TPropertyObject as we don't care about the mid-way structure types, only the end generic result.
+        // can assume the mid-way is correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+        const rows = await this.executeParams(name, values);
+        return singleList(rows);
+    }
+    async executeParamsValue(name, values, allowNone = false) {
+        // can use TPropertyObject as we don't care about the mid-way structure types, only the end generic result.
+        // can assume the mid-way is correct. if not, the results vs generic isn't correct, which is a programmer error and can't be detected at runtime.
+        const row = await this.executeParamsSingle(name, values);
+        if (allowNone && row === undefined)
+            return undefined;
+        if (row === undefined) {
+            if (allowNone)
+                return undefined;
+            throw new Error('executeParamsValue did not return a result and allowNone is false');
+        }
+        return singleList([row])[0];
+    }
+    // helper method to avoid |undefined
+    async executeParamsValueNoNone(name, values) {
+        return (await this.executeParamsValue(name, values));
+    }
+    // this has to be async as it might need to create enums for Postgres etc.
+    // can't use commonsObjectMapObject for the same reason
+    async generateCreateTableSql(table, structure, ifNotExists) {
+        const fields = [];
+        for (const field of Object.keys(structure)) {
+            commonsDatabaseAssertField(field);
+            const type = structure[field];
+            const build = [
+                this.delimit(field),
+                type.render(this.getEngine())
+            ];
+            if (type instanceof CommonsDatabaseTypeEnum) {
+                const createEnum = type.getCreateEnum(this.getEngine());
+                if (createEnum)
+                    await this.noneParams(createEnum);
+            }
+            if (type instanceof CommonsDatabaseTypeNumber) {
+                type.renderAppendCheck(build, field, this.getEngine());
+            }
+            fields.push(build.join(' '));
+        }
+        const query = [
+            `CREATE TABLE ${ifNotExists ? 'IF NOT EXISTS' : ''}`,
+            this.table(table),
+            `(${fields.join(',')})`
+        ];
+        if (this.getEngine() === ECommonsDatabaseEngine.MYSQL)
+            query.push('ENGINE=InnoDB');
+        return query.join(' ');
+    }
+    async createTable(table, structure, ifNotExists = false) {
+        const sql = await this.generateCreateTableSql(table, structure, ifNotExists);
+        await this.noneParams(sql);
+    }
+    async dropTable(table, structure, ifExists = false) {
+        await this.noneParams(`DROP TABLE ${ifExists ? 'IF EXISTS' : ''} ${this.table(table)}`);
+        for (const field of Object.keys(structure)) {
+            commonsDatabaseAssertField(field);
+            const type = structure[field];
+            if (type instanceof CommonsDatabaseTypeEnum) {
+                const dropEnum = type.getDropEnum(this.getEngine());
+                if (dropEnum)
+                    await this.noneParams(dropEnum);
+            }
+        }
+    }
+    async createView(table, name, sql, ifNotExists = false) {
+        await this.noneParams(`CREATE VIEW ${ifNotExists ? 'IF NOT EXISTS' : ''} ${this.view(table, name)} AS ${sql}`);
+    }
+    async dropView(table, name, ifExists = true // non-existant views aren't really much of an issue
+    ) {
+        await this.noneParams(`DROP VIEW ${ifExists ? 'IF EXISTS' : ''} ${this.view(table, name)} CASCADE`);
+    }
+    async createForeignKey(table, destTable, field, destId, onDelete = ECommonsDatabaseReferentialAction.CASCADE, onUpdate = ECommonsDatabaseReferentialAction.CASCADE, constraintName) {
+        const sql = this.generateCreateForeignKeySql(table, destTable, field, destId, onDelete, onUpdate, constraintName);
+        await this.noneParams(sql);
+    }
+    generateCreateForeignKeySql(table, destTable, field, destId, onDelete = ECommonsDatabaseReferentialAction.CASCADE, onUpdate = ECommonsDatabaseReferentialAction.CASCADE, constraintName) {
+        if (!constraintName)
+            constraintName = `f_${table}_${destTable}_${field}_${destId}`;
+        return `
+			ALTER TABLE ${this.table(table)}
+			ADD CONSTRAINT ${this.delimit(constraintName)}
+			FOREIGN KEY (${this.delimit(field)})
+				REFERENCES ${this.delimit(destTable)} (${this.delimit(destId)})
+				ON DELETE ${onDelete}
+				ON UPDATE ${onUpdate}
+		`;
+    }
+    async createUniqueKey(table, fields, constraintName) {
+        const sql = this.generateCreateUniqueKeySql(table, fields, constraintName);
+        await this.noneParams(sql);
+    }
+    generateCreateUniqueKeySql(table, fields, constraintName) {
+        const build = [];
+        const names = [];
+        for (const field of fields) {
+            commonsDatabaseAssertField(field);
+            build.push(this.delimit(field));
+            names.push(field);
+        }
+        if (!constraintName)
+            constraintName = `constraint_unique_${table}_${names.join('_')}`;
+        const query = [
+            'ALTER TABLE',
+            this.table(table),
+            'ADD CONSTRAINT',
+            this.delimit(constraintName),
+            'UNIQUE'
+        ];
+        if (this.getEngine() !== ECommonsDatabaseEngine.POSTGRES)
+            query.push('KEY');
+        query.push(`(${build.join(',')})`);
+        return query.join(' ');
+    }
+    async createIndexKey(table, fields, constraintName) {
+        const sql = this.generateCreateIndexKeySql(table, fields, constraintName);
+        await this.noneParams(sql);
+    }
+    generateCreateIndexKeySql(table, fields, indexName) {
+        const build = [];
+        const names = [];
+        for (const field of fields) {
+            commonsDatabaseAssertField(field);
+            build.push(this.delimit(field));
+            names.push(field);
+        }
+        if (!indexName)
+            indexName = `index_${table}_${names.join('_')}`;
+        return `
+			CREATE INDEX ${this.delimit(indexName)}
+			ON ${this.delimit(table)} (${build.join(',')})
+		`;
+    }
+    async insertOrReplaceRow(method, table, values, conflictFields, autoinc) {
+        const params = {};
+        const fields = [];
+        const qs = [];
+        let i = 1;
+        for (const field of Object.keys(values)) {
+            commonsDatabaseAssertField(field);
+            if (this.getEngine() === ECommonsDatabaseEngine.POSTGRES
+                || this.getEngine() === ECommonsDatabaseEngine.SQLITE) {
+                fields.push(this.delimit(field)); // some databases don't like Table.Field syntax for some reason?
+            }
+            else {
+                fields.push(this.tableField(table, field));
+            }
+            qs.push(`:value${i}`);
+            params[`value${i}`] = values[field];
+            i++;
+        }
+        const query = [];
+        switch (this.getEngine()) {
+            case ECommonsDatabaseEngine.POSTGRES:
+                query.push('INSERT');
+                break;
+            case ECommonsDatabaseEngine.MYSQL:
+            case ECommonsDatabaseEngine.SQLITE:
+                switch (method) {
+                    case ECommonsDatabaseInsertMethod.INSERT:
+                        query.push('INSERT');
+                        break;
+                    case ECommonsDatabaseInsertMethod.UPSERT:
+                        query.push('REPLACE');
+                        break;
+                }
+                break;
+        }
+        query.push(`INTO ${this.table(table)}`);
+        query.push(`(${fields.join(',')})`);
+        query.push(`VALUES (${qs.join(',')})`);
+        if (method === ECommonsDatabaseInsertMethod.UPSERT && this.getEngine() === ECommonsDatabaseEngine.POSTGRES) {
+            if (!conflictFields || conflictFields.length === 0)
+                throw new Error('No conflict fields supplied for a Postgres upsert');
+            const excludeds = Object.keys(values)
+                .filter((field) => !conflictFields.includes(field))
+                .map((field) => `${this.delimit(field)} = EXCLUDED.${this.delimit(field)}`);
+            query.push(`ON CONFLICT (${conflictFields.map((field) => this.delimit(field)).join(',')})`);
+            if (excludeds.length === 0) {
+                query.push('DO NOTHING');
+            }
+            else {
+                query.push(`DO UPDATE SET ${excludeds.join(',')}`);
+            }
+        }
+        if (autoinc !== undefined && this.getEngine() === ECommonsDatabaseEngine.POSTGRES) {
+            query.push(`RETURNING "${autoinc}"`);
+        }
+        if (autoinc !== undefined) {
+            switch (this.getEngine()) {
+                case ECommonsDatabaseEngine.POSTGRES:
+                case ECommonsDatabaseEngine.MYSQL: {
+                    const id = await this.queryParamsValue(query.join(' '), params, 'id', new CommonsDatabaseTypeSerialId());
+                    if (!commonsTypeIsNumber(id) || id < 1)
+                        throw new Error('Autoinc query failed');
+                    return id;
+                }
+                case ECommonsDatabaseEngine.SQLITE: {
+                    await this.noneParams(query.join(' '), params);
+                    return (await this.queryParamsValue('SELECT last_insert_rowid() AS id', undefined, 'id', new CommonsDatabaseTypeInt(ECommonsDatabaseTypeSigned.UNSIGNED, ECommonsDatabaseTypeNull.NOT_NULL)));
+                }
+                default:
+                    throw new Error('Unknown database type for autoincrement value return');
+            }
+        }
+        else {
+            await this.noneParams(query.join(' '), params);
+        }
+    }
+    async insertRow(table, values, autoinc) {
+        return await this.insertOrReplaceRow(ECommonsDatabaseInsertMethod.INSERT, table, values, undefined, autoinc);
+    }
+    async upsertRow(table, values, conflictFields, autoinc) {
+        return await this.insertOrReplaceRow(ECommonsDatabaseInsertMethod.UPSERT, table, values, conflictFields, autoinc);
+    }
+    buildClause(table, inParams, outParams, prefix, delimiter, write) {
+        if (commonsObjectIsEmpty(inParams))
+            throw new Error('No inParams');
+        const build = [];
+        let i = 1;
+        for (const field of Object.keys(inParams)) {
+            commonsDatabaseAssertField(field);
+            const param = inParams[field];
+            if (write
+                && (this.getEngine() === ECommonsDatabaseEngine.POSTGRES
+                    || this.getEngine() === ECommonsDatabaseEngine.SQLITE)) {
+                // postgres and sqlite don't like Table.Field syntax for writing data for some reason?
+                build.push(`${this.delimit(field)} = :${prefix}${i}`);
+            }
+            else {
+                build.push(`${this.tableField(table, field)} = :${prefix}${i}`);
+            }
+            outParams[`${prefix}${i}`] = param;
+            i++;
+        }
+        return build.join(delimiter);
+    }
+    async updateRowsByConditions(table, values, conditions, singular = false) {
+        if (commonsObjectIsEmpty(values))
+            throw new Error('No update values');
+        if (commonsObjectIsEmpty(conditions))
+            throw new Error('No conditions supplied for update');
+        const isTransactionOwner = await this.transactionClaim();
+        try {
+            if (singular) {
+                const count = await this.countRowsByConditions(table, conditions);
+                if (1 !== count)
+                    throw new Error(`Singular check failure: ${count} rows match`);
+            }
+            const params = {};
+            const setClauses = this.buildClause(table, values, params, 'value', ',', true);
+            const whereClauses = this.buildClause(table, conditions, params, 'condition', ' AND ', false);
+            await this.noneParams(`
+						UPDATE ${this.table(table)}
+						SET ${setClauses}
+						WHERE ${whereClauses}
+					`, params);
+            if (isTransactionOwner)
+                await this.transactionCommit();
+        }
+        catch (e) {
+            if (isTransactionOwner)
+                await this.transactionRollback();
+            console.error(e);
+            throw e;
+        }
+    }
+    async deleteRowsByConditions(table, conditions, singular = false) {
+        if (commonsObjectIsEmpty(conditions))
+            throw new Error('No conditions supplied for delete');
+        const isTransactionOwner = await this.transactionClaim();
+        try {
+            if (singular) {
+                const count = await this.countRowsByConditions(table, conditions);
+                if (1 !== count)
+                    throw new Error(`Singular check failure: ${count} rows match`);
+            }
+            const params = {};
+            const whereClauses = this.buildClause(table, conditions, params, 'condition', ' AND ', false);
+            await this.noneParams(`
+						DELETE FROM ${this.table(table)}
+						WHERE ${whereClauses}
+					`, params);
+            if (isTransactionOwner)
+                await this.transactionCommit();
+        }
+        catch (e) {
+            if (isTransactionOwner)
+                await this.transactionRollback();
+            console.error(e);
+            throw e;
+        }
+    }
+    async selectRowsByConditions(table, fields, conditions) {
+        if (commonsObjectIsEmpty(fields))
+            throw new Error('Select rows by conditions supplied zero-length field array');
+        if (commonsObjectIsEmpty(conditions))
+            throw new Error('No conditions supplied for select rows by conditions');
+        const queryFields = [];
+        for (const field of Object.keys(fields)) {
+            commonsDatabaseAssertField(field);
+            if (!(fields[field] instanceof CommonsDatabaseType))
+                throw new Error('Field type is not an instance of CommonsDatabaseType');
+            queryFields.push(this.tableField(table, field));
+        }
+        const params = {};
+        const whereClauses = this.buildClause(table, conditions, params, 'condition', ' AND ', false);
+        return await this.queryParams(`
+					SELECT ${queryFields.join(',')}
+					FROM ${this.table(table)}
+					WHERE ${whereClauses}
+				`, params, fields);
+    }
+    async countRowsByConditions(table, conditions) {
+        if (commonsObjectIsEmpty(conditions))
+            throw new Error('No conditions supplied for count rows by conditions');
+        const params = {};
+        const whereClauses = this.buildClause(table, conditions, params, 'condition', ' AND ', false);
+        return (await this.queryParamsValue(`
+					SELECT COUNT(*) AS ${this.delimit('count')}
+					FROM ${this.table(table)}
+					WHERE ${whereClauses}
+				`, params, 'count', new CommonsDatabaseTypeInt(ECommonsDatabaseTypeSigned.UNSIGNED, ECommonsDatabaseTypeNull.NOT_NULL)));
+    }
+    async doesRowExistByConditions(table, conditions) {
+        return (await this.countRowsByConditions(table, conditions)) > 0;
+    }
+}
+//# sourceMappingURL=commons-sql-database.service.mjs.map