@sqb/connect 4.11.3 → 4.12.1

package/esm/orm/repository.class.js

@@ -22,8 +22,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     create(values, options) {
         return this._execute(async (connection) => {
             const keyValue = await this._create(values, { ...options, connection, returning: true });
-            const result = keyValue &&
-                await this._find(keyValue, { ...options, connection });
+            const result = keyValue && (await this._find(keyValue, { ...options, connection }));
             if (!result)
                 throw new Error('Unable to insert new row');
             return result;
@@ -39,15 +38,16 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             return this._exists(keyValue, { ...options, connection });
         }, options);
     }
+    existsOne(options) {
+        return this._execute(async (connection) => {
+            return this._existsOne({ ...options, connection });
+        }, options);
+    }
     count(options) {
         return this._execute(async (connection) => {
             return this._count({ ...options, connection });
         }, options);
     }
-    /** @deprecated - Use findById instead */
-    find(keyValue, options) {
-        return this.findById(keyValue, options);
-    }
     findById(keyValue, options) {
         return this._execute(async (connection) => {
             return this._find(keyValue, { ...options, connection });
@@ -116,7 +116,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         const keyValues = await CreateCommand.execute({
             ...options,
             entity: this._entity,
-            values
+            values,
         });
         if (options.returning && !keyValues)
             throw new Error('Unable to insert new row');
@@ -130,16 +130,30 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             else
                 filter.push(options.filter);
         }
-        return !!(await CountCommand.execute({
+        return this._existsOne({
             ...options,
             filter,
-            entity: this._entity
-        }));
+        });
+    }
+    async _existsOne(options) {
+        const filter = [];
+        if (options && options.filter) {
+            if (Array.isArray(options.filter))
+                filter.push(...options.filter);
+            else
+                filter.push(options.filter);
+        }
+        const resp = await FindCommand.execute({
+            ...options,
+            filter,
+            entity: this._entity,
+        });
+        return resp.length > 0;
     }
     async _count(options) {
         return CountCommand.execute({
             ...options,
-            entity: this._entity
+            entity: this._entity,
         });
     }
     async _findMany(options) {
@@ -151,7 +165,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     async _findOne(options) {
         const rows = await this._findMany({
             ...options,
-            limit: 1
+            limit: 1,
         });
         return rows && rows[0];
     }
@@ -184,7 +198,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             ...options,
             entity: this._entity,
             filter: options?.filter,
-            params: options?.params
+            params: options?.params,
         });
     }
     async _update(keyValue, values, options) {
@@ -204,7 +218,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
             ...options,
             entity: this._entity,
             values: updateValues,
-            filter
+            filter,
         });
         return rowsAffected ? keyValues : undefined;
     }
@@ -214,7 +228,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
         return await UpdateCommand.execute({
             ...options,
             entity: this._entity,
-            values
+            values,
         });
     }
 }

package/esm/orm/util/apply-mixins.js

@@ -1,9 +1,11 @@
 export function applyMixins(derivedCtor, baseCtor, filter) {
     for (const name of Object.getOwnPropertyNames(baseCtor.prototype)) {
-        if ((name === 'constructor' || name === '__proto__' || name === 'toJSON' || name === 'toString') ||
-            filter && !filter(name))
+        if (name === 'constructor' ||
+            name === '__proto__' ||
+            name === 'toJSON' ||
+            name === 'toString' ||
+            (filter && !filter(name)))
             continue;
-        Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
-            Object.create(null));
+        Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
     }
 }

package/esm/orm/util/extract-keyvalues.js

@@ -4,7 +4,7 @@ export function extractKeyValues(entityDef, valueOrInstance, keepOther) {
     const primaryIndex = EntityMetadata.getPrimaryIndex(entityDef);
     if (!primaryIndex)
         throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
-    const validateCol = (k) => {
+    const validateCol = k => {
         const col = EntityMetadata.getField(entityDef, k);
         if (!col)
             throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);

package/esm/orm/util/parse-fields-projection.js

@@ -0,0 +1,61 @@
+import { splitString } from 'fast-tokenizer';
+const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
+const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
+export class FieldsProjection {
+}
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (FieldsProjection = {}));
+export function parseFieldsProjection(projection, keepCase) {
+    const arr = Array.isArray(projection) ? projection : [projection];
+    if (!(arr && arr.length))
+        return;
+    const out = new FieldsProjection();
+    for (let s of arr) {
+        if (!keepCase)
+            s = s.toLowerCase();
+        parse(s, out);
+    }
+    return out;
+}
+function parse(input, target) {
+    /** Add dot before brackets which is required to split fields */
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => {
+        return s.charAt(0) + '.' + s.substring(1);
+    });
+    const fields = splitString(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = splitString(f, {
+                delimiters: ',',
+                brackets: true,
+                keepBrackets: true,
+            });
+            for (const n of subFields) {
+                parse(n, target);
+            }
+            continue;
+        }
+        const m = FIELD_PATTERN.exec(f);
+        /* istanbul ignore next */
+        if (!m)
+            throw new TypeError(`Invalid field path (${input})`);
+        const fieldName = m[2];
+        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        if (m[1])
+            treeItem.sign = m[1];
+        if (i === fields.length - 1) {
+            delete treeItem.projection;
+        }
+        else {
+            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+        }
+    }
+}

package/esm/orm/util/serialize-field.js

@@ -17,19 +17,19 @@ const padZero = (n) => (n < 9 ? '0' : '') + n;
 function serializeDataValue(dataType, v) {
     if (v == null)
         return;
-    if (v instanceof Date &&
-        (dataType === DataType.DATE || dataType === DataType.TIMESTAMP)) {
-        return v.getFullYear() + '-' +
-            padZero(v.getMonth() + 1) + '-' +
-            padZero(v.getDate()) + (dataType === DataType.TIMESTAMP ?
-            'T' + padZero(v.getHours()) + ':' +
-                padZero(v.getMinutes()) + ':' +
-                padZero(v.getSeconds()) : '');
+    if (v instanceof Date && (dataType === DataType.DATE || dataType === DataType.TIMESTAMP)) {
+        return (v.getFullYear() +
+            '-' +
+            padZero(v.getMonth() + 1) +
+            '-' +
+            padZero(v.getDate()) +
+            (dataType === DataType.TIMESTAMP
+                ? 'T' + padZero(v.getHours()) + ':' + padZero(v.getMinutes()) + ':' + padZero(v.getSeconds())
+                : ''));
     }
     if (v instanceof Buffer)
         return v.toString('base64');
-    if (typeof v === 'number' && (dataType === DataType.SMALLINT ||
-        dataType === DataType.INTEGER))
+    if (typeof v === 'number' && (dataType === DataType.SMALLINT || dataType === DataType.INTEGER))
         return Math.trunc(v);
     if (typeof v === 'bigint')
         return v.toString();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.11.3",
+  "version": "4.12.1",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>",
@@ -25,6 +25,8 @@
     "build:esm": "tsc -b tsconfig-build-esm.json",
     "postbuild": "cp README.md package.json ../../LICENSE ../../build/connect && cp ../../package.cjs.json ../../build/connect/cjs/package.json",
     "lint": "eslint . --max-warnings=0",
+    "lint:fix": "eslint . --max-warnings=0 --fix",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src | npm run clean:dist | npm run clean:cover",
@@ -33,7 +35,8 @@
     "clean:cover": "rimraf ../../coverage/connect"
   },
   "dependencies": {
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
+    "fast-tokenizer": "^1.3.0",
     "lightning-pool": "^4.2.2",
     "lodash": "^4.17.21",
     "power-tasks": "^1.7.3",
@@ -42,15 +45,16 @@
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
     "strict-typed-events": "^2.3.3",
-    "ts-gems": "^3.2.1"
+    "ts-gems": "^3.4.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "@types/lodash": "^4.17.0"
+    "@types/lodash": "^4.17.5",
+    "postgresql-client": "^2.11.2"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.11.3",
-    "reflect-metadata": "^0.1.14 || ^0.2.2"
+    "@sqb/builder": "^4.12.1",
+    "reflect-metadata": "^0.2.2"
   },
   "engines": {
     "node": ">=16.0",

package/types/index.d.ts

@@ -28,4 +28,5 @@ export * from './orm/decorators/link.decorator.js';
 export * from './orm/decorators/primarykey.decorator.js';
 export * from './orm/decorators/transform.decorator.js';
 export { isColumnField, isEmbeddedField, isAssociationField, isEntityClass } from './orm/util/orm.helper.js';
+export * from './orm/util/parse-fields-projection.js';
 export * from './orm/backward.js';

package/types/orm/commands/find.command.d.ts

@@ -2,6 +2,7 @@ import { SqbConnection } from '../../client/sqb-connection.js';
 import { AssociationNode } from '../model/association-node.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
 import { Repository } from '../repository.class.js';
+import { FieldsProjection } from '../util/parse-fields-projection.js';
 import { RowConverter } from './row-converter.js';
 export type FindCommandArgs = {
     entity: EntityMetadata;
@@ -29,9 +30,7 @@ export declare class FindCommand {
         tableAlias?: string;
         converter?: RowConverter;
         entity?: EntityMetadata;
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
+        projection?: FieldsProjection | string | string[];
         sort?: string[];
         prefix?: string;
         suffix?: string;

package/types/orm/decorators/column.decorator.d.ts

@@ -2,3 +2,4 @@ import { DataType } from '@sqb/builder';
 import { ColumnFieldOptions } from '../model/column-field-metadata.js';
 export declare function Column(type?: DataType): PropertyDecorator;
 export declare function Column(options?: ColumnFieldOptions): PropertyDecorator;
+export declare namespace Column { }

package/types/orm/decorators/entity.decorator.d.ts

@@ -28,8 +28,8 @@ export declare namespace Entity {
     function mixin<A, B, C, D>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
     function mixin<A, B, C, D, E>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
     function mixin<A, B, C, D, E, F>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
-    function Pick<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
-    function Omit<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;
+    function Pick<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, (typeof keys)[number]>>;
+    function Omit<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, (typeof keys)[number]>>;
     function Union<A, B>(baseA: Type<A>, baseB: Type<B>): Type<A & B>;
     function Union<A, B, C>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
     function Union<A, B, C, D>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;

package/types/orm/model/field-metadata.d.ts

@@ -10,7 +10,7 @@ export interface FieldMetadata {
     hidden?: boolean;
     /**
      * Indicates whether or not to include this field by default when making queries.
-     * If this set to "true" the field must be requested using "include" or "pick" option.
+     * If this set to "true" the field must be requested using "projection" option.
      */
     exclusive?: boolean;
 }

package/types/orm/orm.const.d.ts

@@ -1,2 +1,3 @@
 export declare const ENTITY_METADATA_KEY: unique symbol;
 export declare const REPOSITORY_KEY: unique symbol;
+export declare const DECORATOR_FACTORY: unique symbol;

package/types/orm/orm.type.d.ts

@@ -8,7 +8,7 @@ export type ColumnAutoGenerationStrategy = 'increment' | 'uuid' | 'rowid' | 'tim
 export type ColumnTransformFunction = (value: any, name: string) => any;
 export type TypeResolver<T> = () => Type<T> | Promise<Type<T>>;
 export type TypeThunk<T = any> = Type<T> | TypeResolver<T>;
-export type EnumValue = (FieldValue)[] | Object;
+export type EnumValue = FieldValue[] | Object;
 export type FieldValue = string | number | boolean | Date | null;
 export type DefaultValueGetter = (obj?: any) => FieldValue | undefined;
 export interface AssociationSettings {

package/types/orm/repository.class.d.ts

@@ -1,16 +1,15 @@
 import { PartialDTO, PatchDTO, StrictOmit, Type } from 'ts-gems';
+import { LogicalOperator } from '@sqb/builder';
 import { FieldInfoMap } from '../client/field-info-map.js';
 import { SqbClient } from '../client/sqb-client.js';
 import { SqbConnection } from '../client/sqb-connection.js';
 import { QueryRequest, TransactionFunction } from '../client/types.js';
 import { EntityMetadata } from './model/entity-metadata.js';
 interface Projection {
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
+    projection?: string | string[];
 }
 interface Filtering {
-    filter?: any;
+    filter?: LogicalOperator | LogicalOperator[] | object | object[];
     params?: any;
 }
 export declare namespace Repository {
@@ -30,7 +29,7 @@ export declare namespace Repository {
     }
     interface FindOptions extends CommandOptions, Projection, Filtering {
     }
-    interface FindOneOptions extends CommandOptions, Projection, Filtering {
+    interface FindOneOptions extends FindOptions {
         sort?: string[];
         offset?: number;
     }
@@ -43,6 +42,8 @@ export declare namespace Repository {
     }
     interface UpdateOptions extends CommandOptions, Projection, Filtering {
     }
+    interface UpdateOnlyOptions extends CommandOptions, Filtering {
+    }
     interface UpdateManyOptions extends CommandOptions, Filtering {
     }
 }
@@ -62,16 +63,15 @@ export declare class Repository<T> extends Repository_base {
     create(values: PartialDTO<T>, options?: Repository.CreateOptions): Promise<PartialDTO<T>>;
     createOnly(values: PartialDTO<T>, options?: StrictOmit<Repository.CreateOptions, keyof Projection>): Promise<void>;
     exists(keyValue: any | Record<string, any>, options?: Repository.ExistsOptions): Promise<boolean>;
+    existsOne(options?: Repository.ExistsOptions): Promise<boolean>;
     count(options?: Repository.CountOptions): Promise<number>;
-    /** @deprecated - Use findById instead */
-    find(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<PartialDTO<T> | undefined>;
     findById(keyValue: any | Record<string, any>, options?: Repository.FindOptions): Promise<PartialDTO<T> | undefined>;
     findOne(options?: Repository.FindOneOptions): Promise<PartialDTO<T> | undefined>;
     findMany(options?: Repository.FindManyOptions): Promise<PartialDTO<T>[]>;
     delete(keyValue: any | Record<string, any>, options?: Repository.DeleteOptions): Promise<boolean>;
     deleteMany(options?: Repository.DeleteManyOptions): Promise<number>;
     update(keyValue: any | Record<string, any>, values: PatchDTO<T>, options?: Repository.UpdateOptions): Promise<PartialDTO<T> | undefined>;
-    updateOnly(keyValue: any | Record<string, any>, values: PatchDTO<T>, options?: StrictOmit<Repository.UpdateOptions, keyof Projection>): Promise<boolean>;
+    updateOnly(keyValue: any | Record<string, any>, values: PatchDTO<T>, options?: Repository.UpdateOnlyOptions): Promise<boolean>;
     updateMany(values: PartialDTO<T>, options?: Repository.UpdateManyOptions): Promise<number>;
     protected _execute(fn: TransactionFunction, opts?: Repository.CommandOptions): Promise<any>;
     protected _create(values: PartialDTO<T>, options: Repository.CreateOptions & {
@@ -81,6 +81,9 @@ export declare class Repository<T> extends Repository_base {
     protected _exists(keyValue: any | Record<string, any>, options: Repository.ExistsOptions & {
         connection: SqbConnection;
     }): Promise<boolean>;
+    protected _existsOne(options: Repository.ExistsOptions & {
+        connection: SqbConnection;
+    }): Promise<boolean>;
     protected _count(options: Repository.CountOptions & {
         connection: SqbConnection;
     }): Promise<number>;

package/types/orm/util/parse-fields-projection.d.ts

@@ -0,0 +1,10 @@
+export declare class FieldsProjection {
+    [key: string]: FieldsProjection.Item;
+}
+export declare namespace FieldsProjection {
+    class Item {
+        sign?: string;
+        projection?: FieldsProjection;
+    }
+}
+export declare function parseFieldsProjection(projection: string | string[], keepCase?: boolean): FieldsProjection | undefined;