@samet-it/be-db-common 1.0.11

package/dist/error/db-invalid-value.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbInvalidValueError = void 0;
+const db_error_1 = require("./db.error");
+class DbInvalidValueError extends db_error_1.DbError {
+    constructor(field, type, where, method) {
+        super(`${field} value is not valid at ${where}#${method}`, { field, type, where, method });
+    }
+}
+exports.DbInvalidValueError = DbInvalidValueError;

package/dist/error/db-not-supported.error.d.ts

@@ -0,0 +1,4 @@
+import { DbError } from "./db.error";
+export declare class DbNotSupportedError extends DbError {
+    constructor(feature: string, where: string, method: string);
+}

package/dist/error/db-not-supported.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbNotSupportedError = void 0;
+const db_error_1 = require("./db.error");
+class DbNotSupportedError extends db_error_1.DbError {
+    constructor(feature, where, method) {
+        super(`${feature} is not supported at ${where}#${method}`, { feature, where, method });
+    }
+}
+exports.DbNotSupportedError = DbNotSupportedError;

package/dist/error/db.error.d.ts

@@ -0,0 +1,7 @@
+import { SametError } from "@samet-it/be-base-common";
+import type { DbErrorOmit } from "./index.types";
+/**
+ * Generic database error
+ * */
+export declare class DbError extends SametError implements DbErrorOmit {
+}

package/dist/error/db.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbError = void 0;
+const be_base_common_1 = require("@samet-it/be-base-common");
+/**
+ * Generic database error
+ * */
+class DbError extends be_base_common_1.SametError {
+}
+exports.DbError = DbError;

package/dist/error/index.d.ts

@@ -0,0 +1,5 @@
+export * from './index.types';
+export * from './db.error';
+export * from './db-execute.error';
+export * from './db-invalid-value.error';
+export * from './db-not-supported.error';

package/dist/error/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./db.error"), exports);
+__exportStar(require("./db-execute.error"), exports);
+__exportStar(require("./db-invalid-value.error"), exports);
+__exportStar(require("./db-not-supported.error"), exports);

package/dist/error/index.types.d.ts

@@ -0,0 +1 @@
+export type DbErrorOmit = Omit<Error, 'message' | 'name' | 'stack'>;

package/dist/error/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './connection';
+export * from './line';
+export * from './repo';
+export * from './error';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./line"), exports);
+__exportStar(require("./repo"), exports);
+__exportStar(require("./error"), exports);

package/dist/line/db-lines.impl.d.ts

@@ -0,0 +1,7 @@
+import type { DbLines } from "./index.types";
+/**
+ * Create new/empty sql lines
+ *
+ * @return {DbLines}
+ * */
+export declare const dbLines: () => DbLines;

package/dist/line/db-lines.impl.js

@@ -0,0 +1,141 @@
+"use strict";
+// ~~console.log(__filename);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbLines = void 0;
+const type_1 = require("@leyyo/type");
+/** @inheritDoc */
+class DbLinesImpl {
+    constructor() {
+        this._lines = [];
+    }
+    /**
+     * Add line for normal, marked, or optional with padding or without padding
+     * */
+    _add(mark, parts) {
+        if (parts.length < 1) {
+            return this;
+        }
+        parts = parts
+            .map(item => {
+            switch (typeof item) {
+                case "string":
+                    const str = item.trim();
+                    return str ? str : undefined;
+                default:
+                    return undefined;
+            }
+        })
+            .filter(item => item !== undefined);
+        if (parts.length < 1) {
+            return this;
+        }
+        this._lines.push({ mark, content: parts.join(' ') });
+        return this;
+    }
+    /** @inheritDoc */
+    marked(mark, ...parts) {
+        return this._add(mark, parts);
+    }
+    /** @inheritDoc */
+    add(...parts) {
+        return this._add(undefined, parts);
+    }
+    /** @inheritDoc */
+    remove(mark) {
+        if (typeof mark !== 'string') {
+            return false;
+        }
+        const index = this._lines.findIndex(line => line.mark === mark);
+        if (index < 0) {
+            return false;
+        }
+        this._lines.splice(index, 1);
+        return true;
+    }
+    /** @inheritDoc */
+    replace(mark, line) {
+        if (typeof mark !== 'string') {
+            return false;
+        }
+        const index = this._lines.findIndex(line => line.mark === mark);
+        if (index < 0) {
+            return false;
+        }
+        if (typeof line !== 'string') {
+            line = '';
+        }
+        this._lines[index] = { mark, content: line };
+        return true;
+    }
+    /** @inheritDoc */
+    both(flag, yes, no) {
+        if (flag) {
+            const type = typeof yes;
+            if (!['string', 'function'].includes(type)) {
+                (0, type_1.assertFunction)(yes, { field: 'yes', method: 'both' });
+            }
+            this.add((typeof yes === 'function') ? yes() : yes);
+        }
+        else {
+            const type = typeof no;
+            if (!['string', 'function'].includes(type)) {
+                (0, type_1.assertFunction)(no, { field: 'no', method: 'both' });
+            }
+            this.add((typeof no === 'function') ? no() : no);
+        }
+        return this;
+    }
+    /** @inheritDoc */
+    yes(flag, yes) {
+        if (flag) {
+            const type = typeof yes;
+            if (!['string', 'function'].includes(type)) {
+                (0, type_1.assertFunction)(yes, { field: 'yes', method: 'yes' });
+            }
+            this.add((typeof yes === 'function') ? yes() : yes);
+        }
+        return this;
+    }
+    /** @inheritDoc */
+    no(flag, no) {
+        if (!flag) {
+            const type = typeof no;
+            if (!['string', 'function'].includes(type)) {
+                (0, type_1.assertFunction)(no, { field: 'no', method: 'no' });
+            }
+            this.add((typeof no === 'function') ? no() : no);
+        }
+        return this;
+    }
+    /** @inheritDoc */
+    clear() {
+        this._lines.splice(0, this._lines.length);
+        return this;
+    }
+    /** @inheritDoc */
+    end() {
+        return this.lines.join('\n');
+    }
+    /** @inheritDoc */
+    get lines() {
+        return this._lines.map(line => line.content);
+    }
+    /** @inheritDoc */
+    get size() {
+        return this._lines.length;
+    }
+    /** @inheritDoc */
+    toString() {
+        return this.end();
+    }
+}
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Create new/empty sql lines
+ *
+ * @return {DbLines}
+ * */
+const dbLines = () => {
+    return new DbLinesImpl();
+};
+exports.dbLines = dbLines;

package/dist/line/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.types';
+export * from './db-lines.impl';

package/dist/line/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index.types"), exports);
+__exportStar(require("./db-lines.impl"), exports);

package/dist/line/index.types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * SQL line item
+ * */
+export interface DbLineItem {
+    mark?: string;
+    content: string;
+}
+/**
+ * SQL lines
+ * */
+export interface DbLines {
+    /**
+     * Add marked line
+     *
+     * @param {string} mark - mark for selected line
+     * @param {...string} parts - line parts
+     * @return {DbLines}
+     */
+    marked(mark: string, ...parts: Array<string>): DbLines;
+    /**
+     * Add line
+     *
+     * @param {...string} parts - line parts
+     * @return {DbLines}
+     */
+    add(...parts: Array<string>): DbLines;
+    /**
+     * Clear all lines
+     * @return {DbLines}
+     */
+    clear(): DbLines;
+    /**
+     * Remove marked line
+     *
+     * @param {string} mark - mark for selected line
+     * @return {boolean} - is removed?
+     */
+    remove(mark: string): boolean;
+    /**
+     * Replace marked line
+     *
+     * @param {string} mark - mark for selected line
+     * @param {string} line - new content
+     * @return {boolean} - is replaced?
+     */
+    replace(mark: string, line: string): boolean;
+    /**
+     * Add new lines by flag
+     * - if flag is true, then `yes` will be added
+     * - if flag is not true, then `no` will be added
+     *
+     * @param {boolean} flag
+     * @param {(function|string)} yes - it's effective when flag is true
+     * @param {(function|string)} no - it's effective when flag is not true
+     * @return {DbLines}
+     */
+    both(flag: boolean, yes: DbLineConditionalLambda | string, no: DbLineConditionalLambda | string): DbLines;
+    /**
+     * Add new lines if flag is true
+     *
+     * @param {boolean} flag
+     * @param {(function|string)} yes - it's effective when flag is true
+     * @return {DbLines}
+     */
+    yes(flag: boolean, yes: DbLineConditionalLambda | string): DbLines;
+    /**
+     * Add new lines if flag is not true
+     *
+     * @param {boolean} flag
+     * @param {(function|string)} no - it's effective when flag is not true
+     * @return {DbLines}
+     */
+    no(flag: boolean, no: DbLineConditionalLambda | string): DbLines;
+    /**
+     * Builds a string from lines
+     *
+     * @return {string}
+     */
+    end(): string;
+    /**
+     * Return all lines
+     *
+     * @return {Array<string>}
+     */
+    get lines(): Array<string>;
+    /**
+     * Return size of lines
+     *
+     * @return {number}
+     */
+    get size(): number;
+    /**
+     * Alis for end() method
+     *
+     * @return {string}
+     */
+    toString(): string;
+}
+/**
+ * SQL conditional lambda
+ * @function
+ * */
+export type DbLineConditionalLambda = () => string;

package/dist/line/index.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/repo/db.repo.d.ts

@@ -0,0 +1,147 @@
+import type { DbCheckKeysResult, DbRepoProps, DbRepoLike, DbRepoOpt, DbRepoDef, DbCheckKeysTuple } from "./index.types";
+import type { DefDims, Entity, IdDocLike, LoggerLike, Pair, Portion, UrnDocLike, UrnTuple, View } from "@samet-it/be-base-common";
+import type { DbConnectionBase, DbExecOpt } from "../connection";
+import type { KeyValue, StrKey } from "@leyyo/common";
+import { type QueryAny, type QueryRegular } from "@leyyo/query";
+/**
+ * DB repository abstract class
+ * */
+export declare abstract class DbRepo<CONN extends DbConnectionBase, OPT extends DbExecOpt, ID extends KeyValue, ENTITY extends Entity<ID>, URN extends UrnDocLike, KEYS extends string, DIMS extends DefDims, PAIR extends Pair<ID>, VIEW extends View<ID>, PORTION extends Portion<ID>> implements DbRepoLike<CONN, OPT, ID, ENTITY, URN, KEYS, DIMS, PAIR, VIEW, PORTION> {
+    /**
+     * Logger
+     * */
+    protected logger: LoggerLike;
+    /**
+     * Option of in-body usage in place of constructor param
+     * */
+    protected _opt: DbRepoOpt<ID, ENTITY>;
+    /**
+     * Produced setting from option
+     * @see _opt
+     * */
+    protected _props: DbRepoProps<CONN, ID, ENTITY>;
+    protected constructor(conn: CONN, opt?: DbRepoOpt<ID, ENTITY>);
+    protected _removeFieldForForbidden(fields: Array<keyof ENTITY>, flag: keyof DbRepoOpt<ID, ENTITY>, field: keyof ENTITY): void;
+    protected _checkForbiddenList(given: Array<keyof ENTITY>, def: Array<keyof ENTITY>): Array<keyof ENTITY>;
+    protected get _now(): string | number;
+    protected get _randomIndexName(): string;
+    protected _indexName(name: string): string;
+    /**
+     * Fetch urn from doc as doc._urn
+     * */
+    protected _urnFromDoc(doc: Partial<ENTITY>, method: string): string;
+    protected _checkKey(value: unknown): DbCheckKeysTuple<ID>;
+    /**
+     * Check array keys as id list or urn list
+     * */
+    protected _checkKeys(keys: Array<KeyValue>): DbCheckKeysResult<ID>;
+    protected _isUrn(key: KeyValue): boolean;
+    /** @inheritDoc */
+    get props(): Readonly<DbRepoProps<CONN, ID, ENTITY>>;
+    /** @inheritDoc */
+    get $def(): DbRepoDef;
+    /** @inheritDoc */
+    $cast<T>(): T;
+    protected _keyToUrn(key: KeyValue): string;
+    /** @inheritDoc */
+    toUrn(urnRec: URN): string;
+    /** @inheritDoc */
+    $toUrnTuple(urnRec: URN): UrnTuple;
+    /** @inheritDoc */
+    get(k1: KeyValue, p1?: OPT | string): Promise<ENTITY | undefined>;
+    /** @inheritDoc */
+    getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    /** @inheritDoc */
+    abstract $getByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    /** @inheritDoc */
+    getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    /** @inheritDoc */
+    abstract $getBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<ENTITY | undefined>;
+    /** @inheritDoc */
+    exists(k1: KeyValue, p1?: OPT | string): Promise<boolean>;
+    /** @inheritDoc */
+    existsByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<boolean>;
+    /** @inheritDoc */
+    abstract $existsByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<boolean>;
+    /** @inheritDoc */
+    existsBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<boolean>;
+    /** @inheritDoc */
+    abstract $existsBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<boolean>;
+    /** @inheritDoc */
+    list(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    /** @inheritDoc */
+    abstract $listByPrimary(keys: string[], p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    /** @inheritDoc */
+    abstract $listBySecondary(keys: Array<KeyValue>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<ENTITY>>;
+    /** @inheritDoc */
+    filter<R = ENTITY, K2 extends string = StrKey<R>>(query: QueryAny<K2 | KEYS | StrKey<ENTITY>>, p1?: OPT | string): Promise<Array<R>>;
+    /** @inheritDoc */
+    abstract $filter<R = ENTITY, K2 extends string = StrKey<R>>(query: QueryRegular<K2 | KEYS | StrKey<ENTITY>>, p1?: OPT | string): Promise<Array<R>>;
+    /** @inheritDoc */
+    insert(doc: ENTITY, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    inserts(docs: Array<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<Array<string>>;
+    /** @inheritDoc */
+    abstract $insert(doc: ENTITY, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    replace(doc: ENTITY, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $replace(doc: ENTITY, opt?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    update(k1: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    updateByPrimary(key: string, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $updateByPrimary(key: string, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    updateBySecondary(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $updateBySecondary(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    set(key: KeyValue, doc: Partial<ENTITY>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    unset(key: KeyValue, fields: Array<keyof ENTITY | string>, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    remove(k1: KeyValue, p1?: OPT | string): Promise<string>;
+    /** @inheritDoc */
+    removeByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $removeByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    removeBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $removeBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    trash(k1: KeyValue, p1?: OPT | string): Promise<string>;
+    /** @inheritDoc */
+    trashByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $trashByPrimary(key: string, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    trashBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    abstract $trashBySecondary(key: KeyValue, p1?: OPT | string, ignoreCheck?: boolean): Promise<string>;
+    /** @inheritDoc */
+    $toDim<R extends IdDocLike<ID>>(doc: ENTITY, dim?: DIMS): Promise<R>;
+    /** @inheritDoc */
+    getDim<R extends IdDocLike<ID>>(key: KeyValue, dim?: DIMS): Promise<R>;
+    /** @inheritDoc */
+    listDims<R extends IdDocLike<ID>>(keys: Array<KeyValue>, dim?: DIMS, ignoreCheck?: boolean): Promise<Array<R>>;
+    /** @inheritDoc */
+    $toPair(doc: ENTITY): Promise<PAIR>;
+    /** @inheritDoc */
+    getPair(key: KeyValue): Promise<PAIR>;
+    /** @inheritDoc */
+    listPairs(keys: Array<KeyValue>, ignoreCheck?: boolean): Promise<Array<PAIR>>;
+    $toView(doc: ENTITY): Promise<VIEW>;
+    /** @inheritDoc */
+    getView(identifier: string): Promise<VIEW>;
+    /** @inheritDoc */
+    listViews(identifiers: Array<string>, ignoreCheck?: boolean): Promise<Array<VIEW>>;
+    /** @inheritDoc */
+    $toPortion(doc: ENTITY): Promise<PORTION>;
+    /** @inheritDoc */
+    getPortion(identifier: string): Promise<PORTION>;
+    /** @inheritDoc */
+    listPortions(identifiers: Array<string>, ignoreCheck?: boolean): Promise<Array<PORTION>>;
+}