orange-orm 3.10.2

package/src/index.d.ts

@@ -0,0 +1,324 @@
+import { Options } from 'ajv';
+import { RequestHandler } from 'express';
+import { ConnectionConfiguration } from 'tedious';
+import { PoolAttributes } from 'oracledb';
+import { AllowedDbMap, DbMapper, MappedDbDef } from './map';
+
+declare function r(config: r.Config): unknown;
+
+declare namespace r {
+
+    function table(name: string): Table;
+    function end(): Promise<void>;
+    function postgres(connectionString: string, options?: PoolOptions): Pool;
+    function sqlite(connectionString: string, options?: PoolOptions): Pool;
+    function sap(connectionString: string, options?: PoolOptions): Pool;
+    function mssql(connectionConfig: ConnectionConfiguration, options?: PoolOptions): Pool;
+    function mssql(connectionString: string, options?: PoolOptions): Pool;
+    function mssqlNative(connectionString: string, options?: PoolOptions): Pool;
+    function mysql(connectionString: string, options?: PoolOptions): Pool;
+    function oracle(config: PoolAttributes, options?: PoolOptions): Pool;
+    function on(type: 'query', cb: (e: QueryEvent) => void): void;
+    function off(type: 'query', cb: (e: QueryEvent) => void): void;
+    function map<V extends AllowedDbMap<V>>(
+		fn: (mapper: DbMapper<{}>) => V
+	): MappedDbDef<V>;
+    function createPatch(original: any[], modified: any[]): JsonPatch;
+    function createPatch(original: any, modified: any): JsonPatch;
+
+    type JsonPatch = Array<{
+        op: "add" | "remove" | "replace" | "copy" | "move" | "test";
+        path: string;
+        value?: any;
+        from?: string;
+    }>;
+
+    export interface QueryEvent {
+        sql: string,
+        parameters: []
+    }
+
+    export interface QueryResult {
+        sql: string,
+        parameters: [],
+        result: []
+    }
+
+    export interface Pool {
+        end(): Promise<void>;
+    }
+
+    export interface PoolOptions {
+        size?: number;
+    }
+
+    export interface Join {
+        by(...columns: string[]): JoinBy;
+    }
+
+    export interface JoinBy {
+        as(propertyName: string): JoinRelation;
+    }
+
+    export abstract class JoinRelation {
+        columns: ColumnDef[];
+        childTable: Table;
+    }
+
+    export interface Table {
+        primaryColumn(column: string): ColumnDef;
+        column(column: string): ColumnDef;
+        join(table: Table): Join;
+        hasMany(join: JoinRelation): HasMany;
+        hasOne(join: JoinRelation): HasOne;
+        formulaDiscriminators(...discriminators: string[]): Table;
+        columnDiscriminators(...discriminators: string[]): Table;
+    }
+
+    export interface HasMany {
+        as(propertyName: string): void;
+    }
+
+    export interface HasOne {
+        as(propertyName: string): void;
+    }
+
+    export interface ColumnDef {
+        serializable(value: boolean): ColumnDef;
+        string(): ColumnOf<string>;
+        numeric(): ColumnOf<number>;
+        uuid(): ColumnOf<string>;
+        binary(): BinaryColumnDef;
+        boolean(): ColumnOf<boolean>;
+        json(): ColumnOf<Record<string, unknown>>;
+        date(): DateColumnDef;
+    }
+    export interface DateColumnDef {
+        validate(validator: (value?: Date | string, row?: object) => void): DateColumnDef;
+        notNull(): DateColumnNotNullDef;
+        JSONSchema(schema: object, options?: Options): DateColumnDef;
+        serializable(value: boolean): DateColumnDef;
+        as(dbName: string): DateColumnDef;
+        default(value: Date | string | null | undefined | (() => Date | string | null | undefined)): DateColumnDef
+        dbNull(value: Date | string | null): DateColumnDef;
+    }
+
+    export interface DateColumnNotNullDef {
+        validate(validator: (value: Date | string, row?: object) => void): DateColumnNotNullDef;
+        JSONSchema(schema: object, options?: Options): DateColumnNotNullDef;
+        serializable(value: boolean): DateColumnNotNullDef;
+        as(dbName: string): DateColumnNotNullDef;
+        default(value: Date | string | null | undefined | (() => Date | string | null | undefined)): DateColumnNotNullDef
+        dbNull(value: Date | string | null): DateColumnNotNullDef;
+    }
+
+    export interface BinaryColumnDef {
+        validate(validator: (value?: Buffer | string, row?: object) => void): BinaryColumnDef;
+        notNull(): BinaryColumnNotNullDef;
+        JSONSchema(schema: object, options?: Options): BinaryColumnDef;
+        serializable(value: boolean): BinaryColumnDef;
+        as(dbName: string): BinaryColumnDef;
+        default(value: Buffer | string | null | undefined | (() => Buffer | string | null | undefined)): BinaryColumnDef
+        dbNull(value: Buffer | string | null): BinaryColumnDef;
+    }
+
+    export interface BinaryColumnNotNullDef {
+        validate(validator: (value: Buffer | string, row?: object) => void): BinaryColumnNotNullDef;
+        JSONSchema(schema: object, options?: Options): BinaryColumnNotNullDef;
+        serializable(value: boolean): BinaryColumnNotNullDef;
+        as(dbName: string): BinaryColumnNotNullDef;
+        default(value: Buffer | string | null | undefined | (() => Buffer | string | null | undefined)): BinaryColumnNotNullDef
+        dbNull(value: Buffer | string | null): BinaryColumnNotNullDef;
+    }
+
+    export interface ColumnOf<T> {
+        validate(validator: (value?: T, row?: object) => void): ColumnOf<T>;
+        notNull(): ColumnNotNullOf<T>;
+        JSONSchema(schema: object, options?: Options): ColumnOf<T>;
+        serializable(value: boolean): ColumnOf<T>;
+        default(value: T | null | undefined | (() => T | null | undefined)): ColumnOf<T>;
+        dbNull(value: T | null): ColumnOf<T>;
+        as(dbName: string): ColumnOf<T>;
+    }
+
+    export interface ColumnNotNullOf<T> {
+        validate(validator: (value: T, row?: object) => void): ColumnNotNullOf<T>;
+        notNull(): ColumnNotNullOf<T>;
+        JSONSchema(schema: object, options?: Options): ColumnNotNullOf<T>;
+        serializable(value: boolean): ColumnNotNullOf<T>;
+        default(value: T | null | undefined | (() => T | null | undefined)): ColumnNotNullOf<T>;
+        dbNull(value: T | null): ColumnNotNullOf<T>;
+        as(dbName: string): ColumnNotNullOf<T>;
+    }
+
+    var filter: Filter;
+    export interface RawFilter {
+        sql: string | (() => string);
+        parameters?: any[];
+    }
+
+    export interface Filter extends RawFilter {
+        and(filter: Filter, ...filters: Filter[]): Filter;
+        or(filter: Filter, ...filters: Filter[]): Filter;
+        not(): Filter;
+    }
+
+    export type Concurrency = 'optimistic' | 'skipOnConflict' | 'overwrite';
+
+    export interface ColumnConcurrency {
+        readonly?: boolean;
+        concurrency?: Concurrency;
+    }
+
+    export interface Express extends RequestHandler {
+        db: import('express').RequestHandler
+        dts: import('express').RequestHandler
+    }
+
+    export interface CustomFilters {
+        [key: string]: (...args: any[]) => RawFilter | CustomFilters
+    }
+
+    export interface BooleanColumn extends ColumnBase<boolean> {
+    }
+
+    export interface JSONColumn extends ColumnBase<object> {
+    }
+
+    export interface UUIDColumn extends ColumnBase<string> {
+    }
+
+    export interface DateColumn extends ColumnBase2<Date, string> {
+    }
+
+    export interface NumberColumn extends ColumnBase<number> {
+    }
+
+    export interface BinaryColumn extends ColumnBase2<Buffer, string> {
+
+    }
+
+    export interface StringColumn extends ColumnBase<string> {
+        startsWith(value: string | null): Filter;
+        /**
+        * ignore case, postgres only
+         */
+        iStartsWith(value: string | null): Filter;
+        endsWith(value: string | null): Filter;
+        /**
+         * ignore case, postgres only
+         */
+        iEndsWith(value: string | null): Filter;
+        contains(value: string | null): Filter;
+        /**
+         * ignore case, postgres only
+         */
+        iContains(value: string | null): Filter;
+        /**
+         * ignore case
+         */
+        iEqual(value: string | null): Filter;
+        /**
+        * ignore case, postgres only         
+        * */
+        iEq(value: string | null): Filter;
+        /**
+         * ignore case, postgres only         
+         */
+        iEq(value: string | null): Filter;
+    }
+
+
+    interface ColumnBase<TType> {
+        equal(value: TType | null): Filter;
+        /**
+         * equal
+         */
+        eq(value: TType | null): Filter;
+        notEqual(value: TType | null): Filter;
+        /**
+         * not equal
+         */
+        ne(value: TType | null): Filter;
+        lessThan(value: TType | null): Filter;
+        /**
+         * less than
+         */
+        lt(value: TType | null): Filter;
+        lessThanOrEqual(value: TType | null): Filter;
+        /**
+         * less than or equal
+         */
+        le(value: TType | null): Filter;
+        greaterThan(value: TType | null): Filter;
+        /**
+         * greater than
+         */
+        gt(value: TType | null): Filter;
+        greaterThanOrEqual(value: TType | null): Filter;
+        /**
+         * greater than or equal
+         */
+        ge(value: TType | null): Filter;
+        between(from: TType, to: TType | null): Filter;
+        in(values: TType[] | null): Filter;
+    }
+
+    interface ColumnBase2<TType, TType2> {
+        equal(value: TType | TType2 | null): Filter;
+        /**
+         * equal
+         */
+        eq(value: TType | TType2 | null): Filter;
+        notEqual(value: TType | TType2 | null): Filter;
+        /**
+         * not equal
+         */
+        ne(value: TType | TType2 | null): Filter;
+        lessThan(value: TType | TType2 | null): Filter;
+        /**
+         * less than
+         */
+        lt(value: TType | TType2 | null): Filter;
+        lessThanOrEqual(value: TType | TType2 | null): Filter;
+        /**
+         * less than or equal
+         */
+        le(value: TType | TType2 | null): Filter;
+        greaterThan(value: TType | TType2 | null): Filter;
+        /**
+         * greater than
+         */
+        gt(value: TType | TType2 | null): Filter;
+        greaterThanOrEqual(value: TType | TType2 | null): Filter;
+        /**
+         * greater than or equal
+         */
+        ge(value: TType | TType2 | null): Filter;
+        between(from: TType | TType2, to: TType | TType2): Filter;
+        in(values: Array<TType | TType2>[] | null): Filter;
+    }
+
+    export interface TransactionOptions {
+        schema?: string[] | string;
+    }
+
+    export type Config = DbConfig | TablesConfig;
+
+    export interface DbConfig {
+        db: Pool | Url | (() => Pool);
+    }
+
+    export type Url = `${'http://' | 'https://'}${string}`;
+
+    export interface TablesConfig {
+        tables: Record<string, Table>
+    }
+
+    export interface TransactionOptions {
+        schema?: string[] | string;
+    }
+
+}
+
+export = r;

package/src/index.js

@@ -0,0 +1,116 @@
+var hostExpress = require('./hostExpress');
+var client = require('./client/index.js');
+var _mySql;
+var _pg;
+var _sqlite;
+var _mssqlNative;
+var _sap;
+var _mssql;
+var _oracle;
+var flags = require('./flags');
+var map = require('./client/map');
+
+var connectViaPool = function(connectionString) {
+	if (connectionString.indexOf && connectionString.indexOf('mysql') === 0)
+		return connectViaPool.mySql.apply(null, arguments);
+	else if (connectionString.indexOf && connectionString.indexOf('postgres') === 0)
+		connectViaPool.pg.apply(null, arguments);
+	else
+		return client.apply(null, arguments);
+};
+connectViaPool.createPatch = client.createPatch;
+connectViaPool.table = require('./table');
+connectViaPool.filter = require('./emptyFilter');
+connectViaPool.commit = require('./table/commit');
+connectViaPool.rollback = require('./table/rollback');
+connectViaPool.end = require('./pools').end;
+connectViaPool.log = require('./table/log').registerLogger;
+connectViaPool.on = require('./table/log').on;
+connectViaPool.off = require('./table/log').off;
+connectViaPool.query = require('./query');
+connectViaPool.lock = require('./lock');
+connectViaPool.schema = require('./pg/schema');
+connectViaPool.map = map.bind(null, connectViaPool);
+
+connectViaPool.http = function(url) {
+	return url;
+};
+
+Object.defineProperty(connectViaPool, 'mysql', {
+	get: function() {
+		if (!_mySql)
+			_mySql = require('./mySql/newDatabase');
+		return _mySql;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'mySql', {
+	get: function() {
+		if (!_mySql)
+			_mySql = require('./mySql/newDatabase');
+		return _mySql;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'postgres', {
+	get: function() {
+		if (!_pg)
+			_pg = require('./pg/newDatabase');
+		return _pg;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'pg', {
+	get: function() {
+		if (!_pg)
+			_pg = require('./pg/newDatabase');
+		return _pg;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'sqlite', {
+	get: function() {
+		if (!_sqlite)
+			_sqlite = require('./sqlite/newDatabase');
+		return _sqlite;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'mssqlNative', {
+	get: function() {
+		if (!_mssqlNative)
+			_mssqlNative = require('./mssql/newDatabase');
+		return _mssqlNative;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'mssql', {
+	get: function() {
+		if (!_mssql)
+			_mssql = require('./tedious/newDatabase');
+		return _mssql;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'sap', {
+	get: function() {
+		if (!_sap)
+			_sap = require('./sap/newDatabase');
+		return _sap;
+	}
+});
+
+Object.defineProperty(connectViaPool, 'oracle', {
+	get: function() {
+		if (!_oracle)
+			_oracle = require('./oracle/newDatabase');
+		return _oracle;
+	}
+});
+
+connectViaPool.express = hostExpress;
+connectViaPool.useHook = function(bool) {
+	flags.useHook = bool;
+};
+
+module.exports = connectViaPool;

package/src/jsconfig.json

@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "target": "es6",
+        "moduleResolution": "node",
+         "checkJs": true
+    }
+
+}

package/src/lock/toIntKey.js

@@ -0,0 +1,35 @@
+function toIntKey(key) {
+	if (isInteger())
+		return key;
+	if (isIntegerString())
+		return trim(key);
+	var intKey = '';
+	for (var i = 0; i < key.length; ++i) {
+		var value = key[i].toUpperCase();
+		value = parseInt(value, 16);
+		if (!isNaN(value))
+			intKey += value;
+	}
+
+	return trim(intKey);
+
+	function isIntegerString() {
+		var pattern = /^-?\d+\.?\d*$/;
+		var reg = new RegExp(pattern);
+		return (typeof key === 'string' && reg.test(key));
+	}
+
+	function isInteger() {
+		return (typeof key === 'number') && (Math.floor(key) === key);
+	}
+
+	function trim(value) {
+		var maxBigInt = '9223372036854775807';
+		value = value.substring(0, 19);
+		if (value > maxBigInt)
+			return value.substring(0,18);
+		return value;
+	}
+}
+
+module.exports = toIntKey;

package/src/lock.js

@@ -0,0 +1,26 @@
+var query = require('./query');
+var toIntKey = require('./lock/toIntKey');
+
+function lock(key, func) {
+	key = toIntKey(key);
+	if(typeof func === 'function') {
+		return inLock(key, func);
+	} else {
+		var sql = 'SELECT pg_advisory_xact_lock(' + key + ')';
+		return query(sql);
+	}
+}
+
+async function inLock(key, func) {
+	await query('SELECT pg_advisory_lock(' + key + ')');
+	try {
+		let result = await func();
+		await query('SELECT pg_advisory_unlock(' + key + ')');
+		return result;
+	} catch(e) {
+		await query('SELECT pg_advisory_unlock(' + key + ')');
+		throw e;
+	}
+}
+
+module.exports = lock;