@itrocks/mysql 0.0.1 → 0.0.3

package/cjs/mysql.d.ts

@@ -5,17 +5,18 @@ import { Entity, MayEntity } from '@itrocks/storage';
 import { Identifier, SearchType } from '@itrocks/storage';
 import { Connection } from 'mariadb';
 export declare const DEBUG = false;
-export interface Dependencies {
+export interface Dependencies<QF extends object = object> {
     applyReadTransformer: <T extends object>(object: T, property: KeyOf<T>, data: AnyObject) => any;
     applySaveTransformer: <T extends object>(object: T, property: KeyOf<T>, data: AnyObject) => any;
     columnOf: (property: string) => string;
     componentOf: <T extends object>(target: T, property: KeyOf<T>) => boolean;
     ignoreTransformedValue: any;
-    queryFunction: (value: any) => [any, string];
+    QueryFunction: Type<QF>;
+    queryFunctionCall: (value: QF) => [any, string];
     storeOf: <T extends object>(target: ObjectOrType<T>) => string | false;
 }
 export declare const depends: Dependencies;
-export declare function dependsOn(dependencies: Partial<Dependencies>): void;
+export declare function dependsOn<QF extends object = object>(dependencies: Partial<Dependencies<QF>>): void;
 export default class Mysql extends DataSource {
     config: {
         host: string;
@@ -33,9 +34,9 @@ export default class Mysql extends DataSource {
     connect(): Promise<Connection>;
     delete<T extends object>(object: Entity<T>, property?: KeyOf<Entity<T>>): Promise<T>;
     deleteId<T extends object>(type: ObjectOrType<T>, id: any, property?: KeyOf<Entity<T>>): Promise<void>;
-    deleteRelated<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
+    deleteRelatedId<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
     insert<T extends object>(object: T): Promise<Entity<T>>;
-    insertRelated<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
+    insertRelatedId<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
     propertiesToSearchSql(search: AnyObject): string;
     propertiesToSql(object: object): string;
     read<T extends object>(type: Type<T>, id: Identifier): Promise<Entity<T>>;

package/cjs/mysql.js

@@ -13,7 +13,9 @@ exports.depends = {
     columnOf: name => name,
     componentOf: () => false,
     ignoreTransformedValue: Symbol('ignoreTransformedValue'),
-    queryFunction: value => [value, '?'],
+    QueryFunction: class {
+    },
+    queryFunctionCall: () => [undefined, ' = ?'],
     storeOf: () => false
 };
 function dependsOn(dependencies) {
@@ -43,7 +45,7 @@ class Mysql extends storage_1.DataSource {
             console.log('DELETE FROM `' + exports.depends.storeOf(type) + '` WHERE `' + exports.depends.columnOf(property) + '` = ?', [id]);
         await connection.query('DELETE FROM `' + exports.depends.storeOf(type) + '` WHERE `' + exports.depends.columnOf(property) + '` = ?', [id]);
     }
-    async deleteRelated(object, property, id) {
+    async deleteRelatedId(object, property, id) {
         const connection = this.connection ?? await this.connect();
         const objectTable = exports.depends.storeOf(object);
         const propertyTable = exports.depends.storeOf(new reflect_1.ReflectProperty(object, property).collectionType.elementType);
@@ -69,7 +71,7 @@ class Mysql extends storage_1.DataSource {
         }
         return entity;
     }
-    async insertRelated(object, property, id) {
+    async insertRelatedId(object, property, id) {
         const connection = this.connection ?? await this.connect();
         const objectTable = exports.depends.storeOf(object);
         const propertyTable = exports.depends.storeOf(new reflect_1.ReflectProperty(object, property).collectionType.elementType);
@@ -84,8 +86,8 @@ class Mysql extends storage_1.DataSource {
         const sql = Object.entries(search)
             .map(([name, value]) => {
             let sql;
-            if (value instanceof exports.depends.queryFunction) {
-                [search[name], sql] = exports.depends.queryFunction(value);
+            if (value instanceof exports.depends.QueryFunction) {
+                [search[name], sql] = exports.depends.queryFunctionCall(value);
             }
             else {
                 sql = ' = ?';

package/esm/mysql.d.ts

@@ -0,0 +1,55 @@
+import { AnyObject } from '@itrocks/class-type';
+import { KeyOf, ObjectOrType, Type } from '@itrocks/class-type';
+import { DataSource } from '@itrocks/storage';
+import { Entity, MayEntity } from '@itrocks/storage';
+import { Identifier, SearchType } from '@itrocks/storage';
+import { Connection } from 'mariadb';
+export declare const DEBUG = false;
+export interface Dependencies<QF extends object = object> {
+    applyReadTransformer: <T extends object>(object: T, property: KeyOf<T>, data: AnyObject) => any;
+    applySaveTransformer: <T extends object>(object: T, property: KeyOf<T>, data: AnyObject) => any;
+    columnOf: (property: string) => string;
+    componentOf: <T extends object>(target: T, property: KeyOf<T>) => boolean;
+    ignoreTransformedValue: any;
+    QueryFunction: Type<QF>;
+    queryFunctionCall: (value: QF) => [any, string];
+    storeOf: <T extends object>(target: ObjectOrType<T>) => string | false;
+}
+export declare const depends: Dependencies;
+export declare function dependsOn<QF extends object = object>(dependencies: Partial<Dependencies<QF>>): void;
+export default class Mysql extends DataSource {
+    config: {
+        host: string;
+        user: string;
+        password: string;
+        database: string;
+    };
+    connection?: Connection;
+    constructor(config: {
+        host: string;
+        user: string;
+        password: string;
+        database: string;
+    });
+    connect(): Promise<Connection>;
+    delete<T extends object>(object: Entity<T>, property?: KeyOf<Entity<T>>): Promise<T>;
+    deleteId<T extends object>(type: ObjectOrType<T>, id: any, property?: KeyOf<Entity<T>>): Promise<void>;
+    deleteRelatedId<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
+    insert<T extends object>(object: T): Promise<Entity<T>>;
+    insertRelatedId<T extends Entity>(object: T, property: KeyOf<T>, id: Identifier): Promise<void>;
+    propertiesToSearchSql(search: AnyObject): string;
+    propertiesToSql(object: object): string;
+    read<T extends object>(type: Type<T>, id: Identifier): Promise<Entity<T>>;
+    readCollection<T extends object, PT extends object>(object: Entity<T>, property: KeyOf<T>, type?: Type<PT>): Promise<Awaited<PT & {
+        id: Identifier;
+    }>[]>;
+    readCollectionIds<T extends object, PT extends object>(object: Entity<T>, property: KeyOf<T>, type?: Type<PT>): Promise<Identifier[]>;
+    readMultiple<T extends object>(type: Type<T>, ids: Identifier[]): Promise<Awaited<T & {
+        id: Identifier;
+    }>[]>;
+    save<T extends object>(object: MayEntity<T>): Promise<Entity<T>>;
+    search<T extends object>(type: Type<T>, search?: SearchType<T>): Promise<Entity<T>[]>;
+    update<T extends object>(object: Entity<T>): Promise<Entity<T>>;
+    valuesFromDb<T extends object>(row: Entity<T>, type: Type<T>): Promise<Entity<T>>;
+    valuesToDb<T extends object>(object: T, type?: Type<T>): Promise<[AnyObject, Function[]]>;
+}

package/esm/mysql.js

@@ -0,0 +1,205 @@
+import { isAnyFunction } from '@itrocks/class-type';
+import { ReflectClass, ReflectProperty } from '@itrocks/reflect';
+import { DataSource } from '@itrocks/storage';
+import { createConnection } from 'mariadb';
+export const DEBUG = false;
+export const depends = {
+    applyReadTransformer: value => value,
+    applySaveTransformer: value => value,
+    columnOf: name => name,
+    componentOf: () => false,
+    ignoreTransformedValue: Symbol('ignoreTransformedValue'),
+    QueryFunction: class {
+    },
+    queryFunctionCall: () => [undefined, ' = ?'],
+    storeOf: () => false
+};
+export function dependsOn(dependencies) {
+    Object.assign(depends, dependencies);
+}
+export default class Mysql extends DataSource {
+    config;
+    connection;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async connect() {
+        const mariaDbConfig = Object.assign(this.config, {
+            allowPublicKeyRetrieval: true,
+            dateStrings: false
+        });
+        return this.connection = await createConnection(mariaDbConfig);
+    }
+    async delete(object, property = 'id') {
+        await this.deleteId(object, object[property], property);
+        return this.disconnectObject(object);
+    }
+    async deleteId(type, id, property = 'id') {
+        const connection = this.connection ?? await this.connect();
+        if (DEBUG)
+            console.log('DELETE FROM `' + depends.storeOf(type) + '` WHERE `' + depends.columnOf(property) + '` = ?', [id]);
+        await connection.query('DELETE FROM `' + depends.storeOf(type) + '` WHERE `' + depends.columnOf(property) + '` = ?', [id]);
+    }
+    async deleteRelatedId(object, property, id) {
+        const connection = this.connection ?? await this.connect();
+        const objectTable = depends.storeOf(object);
+        const propertyTable = depends.storeOf(new ReflectProperty(object, property).collectionType.elementType);
+        const joinTable = [objectTable, propertyTable].sort().join('_');
+        const query = 'DELETE FROM `' + joinTable + '` WHERE ' + objectTable + '_id = ? AND ' + propertyTable + '_id = ?';
+        const values = [object.id, id];
+        if (DEBUG)
+            console.log(query, JSON.stringify(values));
+        connection.query(query, values);
+    }
+    async insert(object) {
+        const connection = this.connection ?? await this.connect();
+        const [values, deferred] = await this.valuesToDb(object);
+        const sql = this.propertiesToSql(values);
+        const query = 'INSERT INTO `' + depends.storeOf(object) + '` SET ' + sql;
+        if (DEBUG)
+            console.log(query, JSON.stringify(Object.values(values)));
+        const result = await connection.query(query, Object.values(values));
+        const id = result.insertId;
+        const entity = this.connectObject(object, ((id >= Number.MIN_SAFE_INTEGER) && (id <= Number.MAX_SAFE_INTEGER)) ? Number(id) : id);
+        for (const callback of deferred) {
+            callback(object);
+        }
+        return entity;
+    }
+    async insertRelatedId(object, property, id) {
+        const connection = this.connection ?? await this.connect();
+        const objectTable = depends.storeOf(object);
+        const propertyTable = depends.storeOf(new ReflectProperty(object, property).collectionType.elementType);
+        const joinTable = [objectTable, propertyTable].sort().join('_');
+        const query = 'INSERT INTO `' + joinTable + '` SET ' + objectTable + '_id = ?, ' + propertyTable + '_id = ?';
+        const values = [object.id, id];
+        if (DEBUG)
+            console.log(query, JSON.stringify(values));
+        connection.query(query, values);
+    }
+    propertiesToSearchSql(search) {
+        const sql = Object.entries(search)
+            .map(([name, value]) => {
+            let sql;
+            if (value instanceof depends.QueryFunction) {
+                [search[name], sql] = depends.queryFunctionCall(value);
+            }
+            else {
+                sql = ' = ?';
+            }
+            return '`' + depends.columnOf(name) + '`' + sql;
+        })
+            .join(' AND ');
+        return sql.length
+            ? ' WHERE ' + sql
+            : '';
+    }
+    propertiesToSql(object) {
+        return Object.keys(object).map(name => '`' + depends.columnOf(name) + '` = ?').join(', ');
+    }
+    async read(type, id) {
+        const connection = this.connection ?? await this.connect();
+        if (DEBUG)
+            console.log('SELECT * FROM `' + depends.storeOf(type) + '` WHERE id = ?', [id]);
+        const rows = await connection.query('SELECT * FROM `' + depends.storeOf(type) + '` WHERE id = ?', [id]);
+        return this.valuesFromDb(rows[0], type);
+    }
+    async readCollection(object, property, type = new ReflectProperty(object, property).collectionType.elementType) {
+        const connection = this.connection ?? await this.connect();
+        const objectTable = depends.storeOf(object);
+        const table = depends.storeOf(type);
+        let query;
+        if (depends.componentOf(object, property)) {
+            query = 'SELECT * FROM `' + table + '` WHERE ' + objectTable + '_id = ?';
+        }
+        else {
+            const joinTable = [objectTable, table].sort().join('_');
+            query = 'SELECT `' + table + '`.* FROM `' + table + '`'
+                + ' INNER JOIN `' + joinTable + '` ON `' + joinTable + '`.' + table + '_id = `' + table + '`.id'
+                + ' WHERE `' + joinTable + '`.' + objectTable + '_id = ?';
+        }
+        const rows = await connection.query(query, [object.id]);
+        return Promise.all(rows.map(row => this.valuesFromDb(row, type)));
+    }
+    async readCollectionIds(object, property, type = new ReflectProperty(object, property).collectionType.elementType) {
+        const connection = this.connection ?? await this.connect();
+        const objectTable = depends.storeOf(object);
+        const propertyTable = depends.storeOf(type);
+        let query;
+        if (depends.componentOf(object, property)) {
+            query = 'SELECT id FROM `' + propertyTable + '` WHERE ' + objectTable + '_id = ?';
+        }
+        else {
+            const joinTable = [objectTable, propertyTable].sort().join('_');
+            query = 'SELECT ' + propertyTable + '_id id FROM `' + joinTable + '`'
+                + ' WHERE `' + joinTable + '`.' + objectTable + '_id = ?';
+        }
+        const rows = await connection.query(query, [object.id]);
+        return Promise.all(rows.map(row => row.id));
+    }
+    async readMultiple(type, ids) {
+        if (!ids.length)
+            return [];
+        const connection = this.connection ?? await this.connect();
+        const questionMarks = Array(ids.length).fill('?').join(', ');
+        if (DEBUG)
+            console.log('SELECT * FROM `' + depends.storeOf(type) + '` WHERE id IN (' + questionMarks + ')', ids);
+        const rows = await connection.query('SELECT * FROM `' + depends.storeOf(type) + '` WHERE id IN (' + questionMarks + ')', ids);
+        return Promise.all(rows.map(row => this.valuesFromDb(row, type)));
+    }
+    async save(object) {
+        return this.isObjectConnected(object)
+            ? this.update(object)
+            : this.insert(object);
+    }
+    async search(type, search = {}) {
+        const connection = this.connection ?? await this.connect();
+        const sql = this.propertiesToSearchSql(search);
+        const [values] = await this.valuesToDb(search, type);
+        if (DEBUG)
+            console.log('SELECT * FROM `' + depends.storeOf(type) + '`' + sql, '[', values, ']');
+        const rows = await connection.query('SELECT * FROM `' + depends.storeOf(type) + '`' + sql, Object.values(values));
+        return Promise.all(rows.map(row => this.valuesFromDb(row, type)));
+    }
+    async update(object) {
+        const connection = this.connection ?? await this.connect();
+        const [values, deferred] = await this.valuesToDb(object);
+        const sql = this.propertiesToSql(values);
+        const query = 'UPDATE `' + depends.storeOf(object) + '` SET ' + sql + ' WHERE id = ?';
+        if (DEBUG)
+            console.log(query, JSON.stringify(Object.values(values).concat([object.id])));
+        await connection.query(query, Object.values(values).concat([object.id]));
+        for (const callback of deferred) {
+            callback(object);
+        }
+        return object;
+    }
+    async valuesFromDb(row, type) {
+        const object = (new type);
+        let property;
+        for (property in row) {
+            const value = await depends.applyReadTransformer(object, property, row);
+            if (value === depends.ignoreTransformedValue)
+                continue;
+            object[property] = value;
+        }
+        return object;
+    }
+    async valuesToDb(object, type) {
+        const typeObject = type ? new type : object;
+        const deferred = [];
+        const values = {};
+        for (const property of type ? Object.keys(object) : new ReflectClass(object).propertyNames) {
+            const value = await depends.applySaveTransformer(typeObject, property, values);
+            if (value === depends.ignoreTransformedValue)
+                continue;
+            if (isAnyFunction(value)) {
+                deferred.push(value);
+                continue;
+            }
+            values[property] = value;
+        }
+        return [values, deferred];
+    }
+}

package/package.json

@@ -55,8 +55,8 @@
 	"scripts": {
 		"build": "npm run build:cjs && npm run build:esm",
 		"build:cjs": "tsc -p tsconfig.cjs.json",
-		"build:esm": "tsc -p tsconfig.esm.json && node esm/esm"
+		"build:esm": "tsc -p tsconfig.esm.json"
 	},
 	"types": "./esm/mysql.d.ts",
-	"version": "0.0.1"
+	"version": "0.0.3"
 }