@sqb/connect 4.20.7 → 4.21.0

package/cjs/orm/repository.class.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-const strict_typed_events_1 = require("strict-typed-events");
-const sqb_connection_js_1 = require("../client/sqb-connection.js");
-const count_command_js_1 = require("./commands/count.command.js");
-const create_command_js_1 = require("./commands/create.command.js");
-const delete_command_js_1 = require("./commands/delete.command.js");
-const find_command_js_1 = require("./commands/find.command.js");
-const update_command_js_1 = require("./commands/update.command.js");
-const entity_metadata_js_1 = require("./model/entity-metadata.js");
-const extract_keyvalues_js_1 = require("./util/extract-keyvalues.js");
-/**
- * @class Repository
- * @template T - The data type class type of the record
- */
-class Repository extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
-    _executor;
-    _entity;
-    _schema;
-    constructor(entityDef, executor, schema) {
-        super();
-        this._executor = executor;
-        this._entity = entityDef;
-        this._schema = schema;
-    }
-    get entity() {
-        return this._entity;
-    }
-    get type() {
-        return this._entity.ctor;
-    }
-    create(input, options) {
-        return this._execute(async (connection) => {
-            const keyValue = await this._create(input, {
-                ...options,
-                connection,
-                returning: true,
-            });
-            const result = keyValue && (await this._find(keyValue, { ...options, connection }));
-            if (!result)
-                throw new Error('Unable to insert new row');
-            return result;
-        }, options);
-    }
-    /**
-     * Creates a new resource but returns nothing
-     *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {Repository.CreateOptions} [options] - The options object
-     * @returns {Promise<any>} A promise that resolves key value(s) of the created record
-     * @throws {Error} if an unknown error occurs while creating the resource
-     */
-    createOnly(input, options) {
-        return this._execute(async (connection) => {
-            const r = await this._create(input, {
-                ...options,
-                connection,
-                returning: true,
-            });
-            const primaryIndex = entity_metadata_js_1.EntityMetadata.getPrimaryIndex(this.entity);
-            if (!primaryIndex || primaryIndex.columns.length > 1)
-                return r;
-            return r[primaryIndex.columns[0]];
-        }, options);
-    }
-    /**
-     * Returns the count of records based on the provided options
-     *
-     * @param {Repository.CountOptions} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of records
-     */
-    count(options) {
-        return this._execute(async (connection) => this._count({ ...options, connection }), options);
-    }
-    /**
-     * Deletes a record from the collection.
-     *
-     * @param {any} keyValue - The ID of the resource to delete.
-     * @param {Repository.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<boolean>} - A Promise that resolves true or false. True when resource deleted.
-     */
-    delete(keyValue, options) {
-        return this._execute(async (connection) => this._delete(keyValue, { ...options, connection }), options);
-    }
-    /**
-     * Deletes multiple documents from the collection that meet the specified filter criteria.
-     *
-     * @param {Repository.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of resources deleted.
-     */
-    deleteMany(options) {
-        return this._execute(async (connection) => this._deleteMany({ ...options, connection }), options);
-    }
-    /**
-     * Checks if a record with the given id exists.
-     *
-     * @param {any} keyValue - The id of the object to check.
-     * @param {Repository.ExistsOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
-     */
-    exists(keyValue, options) {
-        return this._execute(async (connection) => this._exists(keyValue, { ...options, connection }), options);
-    }
-    /**
-     * Checks if a record with the given arguments exists.
-     *
-     * @param {Repository.ExistsOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
-     */
-    existsOne(options) {
-        return this._execute(async (connection) => this._existsOne({ ...options, connection }), options);
-    }
-    findById(keyValue, options) {
-        return this._execute(async (connection) => this._find(keyValue, { ...options, connection }), options);
-    }
-    findOne(options) {
-        return this._execute(async (connection) => await this._findOne({
-            ...options,
-            connection,
-        }), options);
-    }
-    findMany(options) {
-        return this._execute(async (connection) => this._findMany({ ...options, connection }), options);
-    }
-    update(keyValue, input, options) {
-        return this._execute(async (connection) => {
-            const opts = { ...options, connection };
-            const keyValues = await this._update(keyValue, input, opts);
-            if (keyValues)
-                return this._find(keyValues, opts);
-        }, options);
-    }
-    /**
-     * Updates a record in the collection with the specified ID and returns updated record count
-     *
-     * @param {any} keyValue - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {Repository.UpdateOptions} options - The options for updating the document.
-     * @returns {Promise<number>} - A Promise that resolves true or false. True when resource updated.
-     */
-    updateOnly(keyValue, input, options) {
-        return this._execute(async (connection) => !!(await this._update(keyValue, input, { ...options, connection })), options);
-    }
-    /**
-     * Updates multiple records in the collection based on the specified input and options.
-     *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {Repository.UpdateManyOptions} options - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
-     */
-    updateMany(input, options) {
-        return this._execute(async (connection) => this._updateMany(input, { ...options, connection }));
-    }
-    async _execute(fn, opts) {
-        let connection = opts?.connection;
-        if (!connection && this._executor instanceof sqb_connection_js_1.SqbConnection)
-            connection = this._executor;
-        if (connection) {
-            if (this._schema)
-                await connection.setSchema(this._schema);
-            return fn(connection);
-        }
-        return this._executor.acquire(async (conn) => {
-            if (this._schema)
-                await conn.setSchema(this._schema);
-            await this.emitAsyncSerial('acquire', conn);
-            return fn(conn);
-        });
-    }
-    async _create(values, options) {
-        if (!values)
-            throw new TypeError('You must provide values');
-        const keyValues = await create_command_js_1.CreateCommand.execute({
-            ...options,
-            entity: this._entity,
-            values,
-        });
-        if (options.returning && !keyValues)
-            throw new Error('Unable to insert new row');
-        return keyValues;
-    }
-    async _exists(keyValue, options) {
-        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
-        if (options && options.filter) {
-            if (Array.isArray(options.filter))
-                filter.push(...options.filter);
-            else
-                filter.push(options.filter);
-        }
-        return this._existsOne({
-            ...options,
-            filter,
-        });
-    }
-    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 find_command_js_1.FindCommand.execute({
-            ...options,
-            filter,
-            entity: this._entity,
-        });
-        return resp.length > 0;
-    }
-    async _count(options) {
-        return count_command_js_1.CountCommand.execute({
-            ...options,
-            entity: this._entity,
-        });
-    }
-    async _findMany(options) {
-        return await find_command_js_1.FindCommand.execute({
-            ...options,
-            entity: this._entity,
-        });
-    }
-    async _findOne(options) {
-        const rows = await this._findMany({
-            ...options,
-            limit: 1,
-        });
-        return rows && rows[0];
-    }
-    async _find(keyValue, options) {
-        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
-        if (options && options.filter) {
-            if (Array.isArray(options.filter))
-                filter.push(...options.filter);
-            else
-                filter.push(options.filter);
-        }
-        return await this._findOne({ ...options, filter, offset: 0 });
-    }
-    async _delete(keyValue, options) {
-        const filter = [(0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true)];
-        if (options && options.filter) {
-            if (Array.isArray(options.filter))
-                filter.push(...options.filter);
-            else
-                filter.push(options.filter);
-        }
-        return !!(await delete_command_js_1.DeleteCommand.execute({
-            ...options,
-            filter,
-            entity: this._entity,
-        }));
-    }
-    async _deleteMany(options) {
-        return delete_command_js_1.DeleteCommand.execute({
-            ...options,
-            entity: this._entity,
-            filter: options?.filter,
-            params: options?.params,
-        });
-    }
-    async _update(keyValue, values, options) {
-        if (!values)
-            throw new TypeError('You must provide values');
-        const keyValues = (0, extract_keyvalues_js_1.extractKeyValues)(this._entity, keyValue, true);
-        const filter = [keyValues];
-        if (options.filter) {
-            if (Array.isArray(options.filter))
-                filter.push(...options.filter);
-            else
-                filter.push(options.filter);
-        }
-        const updateValues = { ...values };
-        Object.keys(keyValues).forEach(k => delete updateValues[k]);
-        const rowsAffected = await update_command_js_1.UpdateCommand.execute({
-            ...options,
-            entity: this._entity,
-            values: updateValues,
-            filter,
-        });
-        return rowsAffected ? keyValues : undefined;
-    }
-    async _updateMany(values, options) {
-        if (!values)
-            throw new TypeError('You must provide values');
-        return await update_command_js_1.UpdateCommand.execute({
-            ...options,
-            entity: this._entity,
-            values,
-        });
-    }
-}
-exports.Repository = Repository;

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyMixins = applyMixins;
-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))) {
-            continue;
-        }
-        Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
-            Object.create(null));
-    }
-}

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

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractKeyValues = extractKeyValues;
-const entity_metadata_js_1 = require("../model/entity-metadata.js");
-const orm_helper_js_1 = require("./orm.helper.js");
-function extractKeyValues(entityDef, valueOrInstance, keepOther) {
-    const primaryIndex = entity_metadata_js_1.EntityMetadata.getPrimaryIndex(entityDef);
-    if (!primaryIndex)
-        throw new Error(`No primary fields defined for "${entityDef.name}" entity`);
-    const validateCol = k => {
-        const col = entity_metadata_js_1.EntityMetadata.getField(entityDef, k);
-        if (!col)
-            throw new Error(`Unknown column (${k}) defined as primary key in entity "${entityDef.name}"`);
-        if (!(0, orm_helper_js_1.isColumnField)(col)) {
-            throw new Error(`Column (${k}) defined as primary key in entity "${entityDef.name}" is not a data column`);
-        }
-    };
-    // if entity's primary key has more than one key field
-    if (primaryIndex.columns.length > 1) {
-        if (typeof valueOrInstance !== 'object') {
-            throw new Error(`"${entityDef.name}" entity` +
-                ` has more than one primary key field and you must provide all values with an key/value pair`);
-        }
-        const valueKeys = Object.keys(valueOrInstance);
-        const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
-        const out = {};
-        for (const k of primaryIndex.columns) {
-            const i = valueKeysUpper.indexOf(k.toUpperCase());
-            if (i < 0)
-                throw new Error(`Value of key field "${entityDef.name}.${k}" required to perform this operation`);
-            validateCol(k);
-            out[k] = valueOrInstance[valueKeys[i]];
-        }
-        if (keepOther) {
-            for (let i = 0; i < valueKeys.length; i++) {
-                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
-                    continue;
-                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
-            }
-        }
-        return out;
-    }
-    const primaryColumnName = primaryIndex.columns[0];
-    validateCol(primaryColumnName);
-    if (typeof valueOrInstance === 'object') {
-        const valueKeys = Object.keys(valueOrInstance);
-        const valueKeysUpper = valueKeys.map(x => x.toUpperCase());
-        const k = valueKeysUpper.indexOf(primaryColumnName.toUpperCase());
-        if (k < 0) {
-            throw new Error(`Value of key field "${entityDef.name}.${primaryColumnName}" required to perform this operation`);
-        }
-        const out = { [primaryColumnName]: valueOrInstance[valueKeys[k]] };
-        if (keepOther) {
-            for (let i = 0; i < valueKeys.length; i++) {
-                if (primaryIndex.columns.find(x => x.toUpperCase() === valueKeysUpper[i]))
-                    continue;
-                out[valueKeys[i]] = valueOrInstance[valueKeys[i]];
-            }
-        }
-        return out;
-    }
-    return { [primaryColumnName]: valueOrInstance };
-}

package/cjs/orm/util/orm.helper.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAssociationField = exports.isEmbeddedField = void 0;
-exports.isClass = isClass;
-exports.isEntityClass = isEntityClass;
-exports.isColumnField = isColumnField;
-exports.resolveEntity = resolveEntity;
-exports.resolveEntityMeta = resolveEntityMeta;
-const orm_const_js_1 = require("../orm.const.js");
-function isClass(fn) {
-    return typeof fn === 'function' && /^\s*class/.test(fn.toString());
-}
-function isEntityClass(fn) {
-    return isClass(fn) && Reflect.hasMetadata(orm_const_js_1.ENTITY_METADATA_KEY, fn);
-}
-function isColumnField(f) {
-    return !!(f && f.name && f.kind === 'column');
-}
-const isEmbeddedField = (f) => !!(f && f.name && f.kind === 'object');
-exports.isEmbeddedField = isEmbeddedField;
-const isAssociationField = (f) => !!(f && f.name && f.kind === 'association');
-exports.isAssociationField = isAssociationField;
-async function resolveEntity(ctorThunk) {
-    if (typeof ctorThunk !== 'function')
-        return;
-    if (!isClass(ctorThunk))
-        ctorThunk = await ctorThunk();
-    if (isEntityClass(ctorThunk))
-        return ctorThunk;
-}
-async function resolveEntityMeta(ctorThunk) {
-    const ctor = await resolveEntity(ctorThunk);
-    return ctor && Reflect.getMetadata(orm_const_js_1.ENTITY_METADATA_KEY, ctor);
-}

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

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldsProjection = void 0;
-exports.parseFieldsProjection = parseFieldsProjection;
-const fast_tokenizer_1 = require("fast-tokenizer");
-const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
-const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
-class FieldsProjection {
-}
-exports.FieldsProjection = FieldsProjection;
-(function (FieldsProjection) {
-    class Item {
-        sign;
-        projection;
-    }
-    FieldsProjection.Item = Item;
-})(FieldsProjection || (exports.FieldsProjection = FieldsProjection = {}));
-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 => s.charAt(0) + '.' + s.substring(1));
-    const fields = (0, fast_tokenizer_1.splitString)(input, {
-        delimiters: '.',
-        brackets: true,
-        keepBrackets: false,
-    });
-    for (let i = 0; i < fields.length; i++) {
-        const f = fields[i];
-        if (f.includes(',')) {
-            const subFields = (0, fast_tokenizer_1.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/cjs/orm/util/serialize-field.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeColumn = serializeColumn;
-const builder_1 = require("@sqb/builder");
-const orm_helper_js_1 = require("./orm.helper.js");
-function serializeColumn(col, v) {
-    if ((0, orm_helper_js_1.isColumnField)(col)) {
-        if (col.isArray) {
-            if (Array.isArray(v))
-                return v.map(x => serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, x));
-            return [serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v)];
-        }
-        return serializeDataValue(col.dataType || builder_1.DataType.VARCHAR, v);
-    }
-    if (typeof v === 'object' && typeof v.toJSON === 'function')
-        return v.toJSON();
-    return v;
-}
-const padZero = (n) => (n < 9 ? '0' : '') + n;
-function serializeDataValue(dataType, v) {
-    if (v == null)
-        return;
-    if (v instanceof Date &&
-        (dataType === builder_1.DataType.DATE || dataType === builder_1.DataType.TIMESTAMP)) {
-        return (v.getFullYear() +
-            '-' +
-            padZero(v.getMonth() + 1) +
-            '-' +
-            padZero(v.getDate()) +
-            (dataType === builder_1.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 === builder_1.DataType.SMALLINT || dataType === builder_1.DataType.INTEGER))
-        return Math.trunc(v);
-    if (typeof v === 'bigint')
-        return v.toString();
-    if (v && typeof v === 'object' && typeof v.toJSON === 'function')
-        return v.toJSON();
-    return v;
-}

package/cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/esm/orm/model/association-field-metadata.js

@@ -1,20 +0,0 @@
-import _ from 'lodash';
-export var AssociationFieldMetadata;
-(function (AssociationFieldMetadata) {
-    function create(entity, name, association, options = {}) {
-        const result = {
-            kind: 'association',
-            entity,
-            name,
-            association,
-        };
-        if (options)
-            AssociationFieldMetadata.assign(result, options);
-        return result;
-    }
-    AssociationFieldMetadata.create = create;
-    function assign(target, options) {
-        Object.assign(target, _.omit(options, ['entity', 'name', 'kind', 'association']));
-    }
-    AssociationFieldMetadata.assign = assign;
-})(AssociationFieldMetadata || (AssociationFieldMetadata = {}));

package/esm/orm/model/column-field-metadata.js

@@ -1,28 +0,0 @@
-import _ from 'lodash';
-export var ColumnFieldMetadata;
-(function (ColumnFieldMetadata) {
-    function create(entity, name, options = {}) {
-        const result = {
-            kind: 'column',
-            entity,
-            name,
-            fieldName: name,
-        };
-        if (options)
-            ColumnFieldMetadata.assign(result, options);
-        return result;
-    }
-    ColumnFieldMetadata.create = create;
-    function assign(target, options) {
-        Object.assign(target, _.omit(options, ['entity', 'name', 'kind']));
-    }
-    ColumnFieldMetadata.assign = assign;
-    function checkEnumValue(col, v) {
-        if (v === undefined || !col.enum || (v == null && !col.notNull))
-            return;
-        const enumKeys = Array.isArray(col.enum) ? col.enum : Object.keys(col.enum);
-        if (!enumKeys.includes(v))
-            throw new Error(`${col.entity.name}.${col.name} value must be one of (${enumKeys})`);
-    }
-    ColumnFieldMetadata.checkEnumValue = checkEnumValue;
-})(ColumnFieldMetadata || (ColumnFieldMetadata = {}));

package/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/types/index.d.cts

@@ -1,33 +0,0 @@
-import 'reflect-metadata';
-export * from './client/adapter.js';
-export * from './client/cursor.js';
-export * from './client/extensions.js';
-export * from './client/sqb-client.js';
-export * from './client/sqb-connection.js';
-export * from './client/sqb-error.js';
-export * from './client/types.js';
-export * from './orm/backward.js';
-export * from './orm/base-entity.js';
-export * from './orm/decorators/column.decorator.js';
-export * from './orm/decorators/embedded.decorator.js';
-export * from './orm/decorators/entity.decorator.js';
-export * from './orm/decorators/events.decorator.js';
-export * from './orm/decorators/foreignkey.decorator.js';
-export * from './orm/decorators/index.decorator.js';
-export * from './orm/decorators/link.decorator.js';
-export * from './orm/decorators/primarykey.decorator.js';
-export * from './orm/decorators/transform.decorator.js';
-export * from './orm/model/association.js';
-export * from './orm/model/association-field-metadata.js';
-export * from './orm/model/association-node.js';
-export * from './orm/model/column-field-metadata.js';
-export * from './orm/model/embedded-field-metadata.js';
-export * from './orm/model/entity-metadata.js';
-export * from './orm/model/field-metadata.js';
-export * from './orm/model/index-metadata.js';
-export * from './orm/model/link-chain.js';
-export * from './orm/orm.const.js';
-export * from './orm/orm.type.js';
-export * from './orm/repository.class.js';
-export { isAssociationField, isColumnField, isEmbeddedField, isEntityClass, } from './orm/util/orm.helper.js';
-export * from './orm/util/parse-fields-projection.js';