@samet-it/be-couchbase-common 1.0.1

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

@@ -0,0 +1,163 @@
+import type { Scope, Cluster, Collection, QueryResult, QueryOptions } from "couchbase";
+import type { IgnoreFieldsByType, ReplaceType } from "@leyyo/common";
+import type { CbRepoDef } from "../repo";
+export interface CbAdapterServiceLike {
+    /**
+     * Field name
+     * */
+    field(field: string): string;
+    /**
+     * Field name
+     * */
+    f(field: string): string;
+    /**
+     * Basic value: string
+     * */
+    string(value: string): string;
+    /**
+     * Basic value: string
+     * */
+    s(value: string): string;
+    /**
+     * Complex value
+     * */
+    value(value: unknown): string;
+    /**
+     * Complex value
+     * */
+    v(value: unknown): string;
+    /**
+     * Flatten query result to rows
+     * */
+    flatten<T>(result: QueryResult<T>): Array<T>;
+    /**
+     * Check rows and discard trashed
+     * */
+    rows<T>(rows: Array<T>): Array<T>;
+    /**
+     * Check row and discard trashed
+     * */
+    row<T>(row: T): T | undefined;
+    /**
+     * Return first row of rows
+     * */
+    first<T>(rows: Array<T>): T | undefined;
+    /**
+     * Check error
+     * */
+    checkError(err: Error): void;
+    /**
+     * Check error with operation
+     * */
+    checkError(op: string, err: Error): void;
+    /**
+     * Create index for multiple fields
+     * */
+    createIndex<T = Record<string, unknown>>(coll: Collection, fields: Array<keyof T | string>, name: string): Promise<void>;
+    /**
+     * Create index for a field
+     * */
+    createIndex<T = Record<string, unknown>>(coll: Collection, field: keyof T | string, name?: string): Promise<void>;
+    /**
+     * Create base indices for system fields
+     * */
+    createBaseIndices(coll: Collection, ...keys: Array<keyof CbEntity>): Promise<void>;
+    /**
+     * Create primary key
+     * */
+    createPk(coll: Collection): Promise<void>;
+    /**
+     * Cast dates
+     * */
+    castDates<T>(given: ReplaceType<T, Date, string> | T, ...fields: Array<IgnoreFieldsByType<T, Date>>): void;
+    /**
+     * Cast dates for an array
+     * */
+    castDatesForList<T>(given: Array<ReplaceType<T, Date, string> | T>, ...fields: Array<IgnoreFieldsByType<T, Date>>): void;
+    /**
+     * Execute an sql
+     * */
+    exec<T>(opt: CbExecRec<T>): Promise<T>;
+    /**
+     * Execute an sql
+     * */
+    exec2<T>(repo: CbRepoDef, sql: string, opt?: CbExecOpt): Promise<Array<T>>;
+    exec2First<T>(repo: CbRepoDef, sql: string, opt?: CbExecOpt): Promise<T | undefined>;
+    execExtended<T>(repo: CbRepoDef, sql: string, query: QueryOptions, opt?: CbExecOpt): Promise<Array<T>>;
+    execFirstExtended<T>(repo: CbRepoDef, sql: string, query: QueryOptions, opt?: CbExecOpt): Promise<T | undefined>;
+    /**
+     * Connect to DB
+     * */
+    connectDb(): Promise<Cluster>;
+}
+export interface CbEntity {
+    /**
+     * Id
+     * */
+    id: string;
+    /**
+     * Created at
+     * */
+    createdAt: string;
+    /**
+     * Updated at
+     * */
+    updatedAt: string;
+    /**
+     * Urn
+     * */
+    _urn?: string;
+    /**
+     * Trash id if it's trashed
+     * */
+    _trashId?: string;
+}
+export interface CbErrorRec {
+    count: number;
+    log: boolean;
+    known?: boolean;
+}
+type CbIgnoreFields<T, I> = {
+    [K in keyof T]: T[K] extends I ? K : never;
+}[keyof T];
+type CbReplaceType<T, O, N> = {
+    [P in keyof T]: T[P] extends O ? N : T[P];
+};
+export interface CbExecRec<T> {
+    /**
+     * Promise function
+     * */
+    promise: Promise<T>;
+    /**
+     * Name of SQL
+     * */
+    name?: string;
+    /**
+     * Ignored errors
+     * */
+    ignoredErrors?: Omit<Error, 'message'> | Array<Omit<Error, 'message'>>;
+}
+export interface CbExecMutationOpt {
+    /**
+     * Name of SQL
+     * */
+    name?: string;
+    /**
+     * Ignored errors
+     * */
+    ignoredErrors?: CbError[];
+}
+export interface CbExecOpt extends CbExecMutationOpt {
+    /**
+     * Name of SQL
+     * */
+    printSql?: string;
+}
+export interface CbExecTrashOpt extends CbExecOpt {
+    trashId?: string;
+}
+export type CbIgnoreDate<T> = CbReplaceType<T, Date, string>;
+export type CbIgnoreDateKeys<T> = CbIgnoreFields<T, Date>;
+export type CbScopeCollection = [Scope, Collection];
+export type CbError = Omit<Error, 'message'>;
+export {};

package/dist/adapter/index.types.js

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

package/dist/assets/source.MD

@@ -0,0 +1 @@
+https://medium.com/@ozkersemih/connect-to-couchbase-via-nestjs-2a3087cfef43

package/dist/config/couchbase-common.config.d.ts

@@ -0,0 +1,2 @@
+import type { CouchbaseCommonConf } from "./index.types";
+export declare const couchbaseCommonConfig: import("@leyyo/env").EnvScopeRuntime<CouchbaseCommonConf>;

package/dist/config/couchbase-common.config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.couchbaseCommonConfig = void 0;
+const env_1 = require("@leyyo/env");
+exports.couchbaseCommonConfig = env_1.envCore.configure
+    .scope('CouchbaseCommon')
+    .field('CB_HOST').text().required().end
+    .field('CB_USER').text().required().end
+    .field('CB_PASS').text().required().end
+    .field('CB_BUCKET').text().required().end
+    .field('CB_SCOPE').text().required().end
+    .field('CB_CREATE_INDICES').boolean().def(false).end
+    .runtime;

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './couchbase-common.config';
+export * from './index.types';

package/dist/config/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("./couchbase-common.config"), exports);
+__exportStar(require("./index.types"), exports);

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

@@ -0,0 +1,31 @@
+import type { EnvBase } from "@leyyo/env";
+export declare namespace NodeJS {
+    interface ProcessEnv extends CouchbaseCommonConf {
+    }
+}
+export interface CouchbaseCommonConf extends EnvBase {
+    /**
+     * DB Host
+     * */
+    readonly CB_HOST: string;
+    /**
+     * DB User
+     * */
+    readonly CB_USER: string;
+    /**
+     * DB Password
+     * */
+    readonly CB_PASS: string;
+    /**
+     * Current bucket (database name)
+     * */
+    readonly CB_BUCKET: string;
+    /**
+     * Current scope (schema name)
+     * */
+    readonly CB_SCOPE: string;
+    /**
+     * Create indices when it's started
+     * */
+    readonly CB_CREATE_INDICES: boolean;
+}

package/dist/config/index.types.js

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

package/dist/filter/cb-filter-util.impl.d.ts

@@ -0,0 +1,2 @@
+import type { CbFilterUtil } from "./index.types";
+export declare const cbFilterUtil: CbFilterUtil;

package/dist/filter/cb-filter-util.impl.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cbFilterUtil = void 0;
+const common_1 = require("@leyyo/common");
+class CbFilterUtilImpl {
+    _where(opt) {
+        const result = opt.whereUsed ? 'AND' : 'WHERE';
+        opt.whereUsed = true;
+        return result;
+    }
+    /** @inheritDoc */
+    readOne(value, fn) {
+        if (!common_1.$is.text(value)) {
+            return undefined;
+        }
+        if (typeof fn === 'function') {
+            return fn(value);
+        }
+        return value;
+    }
+    /** @inheritDoc */
+    readArray(value, fn) {
+        if (!common_1.$is.text(value)) {
+            return undefined;
+        }
+        if (typeof fn !== 'function') {
+            fn = v => (v === '') ? undefined : v;
+        }
+        const arr = value.split(',')
+            .map(v => fn(v.trim()))
+            .filter(v => v !== undefined);
+        return arr.length > 0 ? arr : undefined;
+    }
+    /** @inheritDoc */
+    readBetween(value, fn) {
+        if (!common_1.$is.text(value)) {
+            return undefined;
+        }
+        if (typeof fn !== 'function') {
+            fn = v => (v === '') ? undefined : v;
+        }
+        const arr = value.split(',')
+            .map(v => fn(v.trim()));
+        let min = fn(arr[0]);
+        let max = fn(arr[1]);
+        if (min === undefined && max === undefined) {
+            return undefined;
+        }
+        return [min, max];
+    }
+    /** @inheritDoc */
+    sqlArrays(opt, field, items) {
+        if (Array.isArray(items) && items.length > 0) {
+            items = items.map(v => (v instanceof Date) ? v.toISOString() : v);
+            if (items.length === 1) {
+                return `${this._where(opt)} ${field} = "${items[0]}"`;
+            }
+            else {
+                return `${this._where(opt)} ${field} IN [${items.map(c => `"${c}"`).join(',')}]`;
+            }
+        }
+    }
+    /** @inheritDoc */
+    sqlBool(opt, field, value) {
+        if (typeof value === 'boolean') {
+            return `${this._where(opt)} ${field} = ${value ? 'true' : 'false'}`;
+        }
+        return undefined;
+    }
+    /** @inheritDoc */
+    sqlBetween(opt, field, value) {
+        if (Array.isArray(value) && value.length === 2) {
+            const [first, last] = value.map(v => (v instanceof Date) ? v.toISOString() : v);
+            if (first !== undefined && last !== undefined) {
+                return `${this._where(opt)} ${field} BETWEEN "${first}" AND "${last}"`;
+            }
+            else if (first !== undefined && last === undefined) {
+                return `${this._where(opt)} ${field} >= "${first}"`;
+            }
+            else if (first === undefined && last !== undefined) {
+                return `${this._where(opt)} ${field} <= "${last}"`;
+            }
+        }
+        return undefined;
+    }
+}
+// noinspection JSUnusedGlobalSymbols
+exports.cbFilterUtil = new CbFilterUtilImpl();

package/dist/filter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.types';
+export * from './cb-filter-util.impl';

package/dist/filter/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("./cb-filter-util.impl"), exports);

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

@@ -0,0 +1,32 @@
+import type { CbLine } from "../line";
+export type FilterCastLambda<T> = (v: unknown) => T;
+export interface CbFilterUtil {
+    /**
+     * Read one query parameter
+     * */
+    readOne<T = string>(value: unknown, fn?: FilterCastLambda<T>): T | undefined;
+    /**
+     * Read an array query parameter
+     * */
+    readArray<T = string>(value: unknown, fn?: FilterCastLambda<T>): Array<T> | undefined;
+    /**
+     * Read range query parameter
+     * */
+    readBetween<T = string>(value: unknown, fn?: FilterCastLambda<T>): [T | undefined, T | undefined] | undefined;
+    /**
+     * Builds a sql for array
+     * */
+    sqlArrays(opt: CbFilterUtilWhereOpt, field: string, items: Array<string>): string | undefined;
+    /**
+     * Builds a sql for boolean
+     * */
+    sqlBool(opt: CbFilterUtilWhereOpt, field: string, value: boolean | undefined): string | undefined;
+    /**
+     * Builds a sql for between
+     * */
+    sqlBetween(opt: CbFilterUtilWhereOpt, field: string, value: [unknown, unknown]): string | undefined;
+}
+export interface CbFilterUtilWhereOpt {
+    lines: CbLine;
+    whereUsed: boolean;
+}

package/dist/filter/index.types.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './adapter';
+export * from './config';
+export * from './filter';
+export * from './line';
+export * from './repo';
+export { QueryResult as CbResult } from 'couchbase';

package/dist/index.js

@@ -0,0 +1,25 @@
+"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 });
+exports.CbResult = void 0;
+__exportStar(require("./adapter"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./filter"), exports);
+__exportStar(require("./line"), exports);
+__exportStar(require("./repo"), exports);
+// noinspection JSUnusedGlobalSymbols
+var couchbase_1 = require("couchbase");
+Object.defineProperty(exports, "CbResult", { enumerable: true, get: function () { return couchbase_1.QueryResult; } });

package/dist/line/cb-line.impl.d.ts

@@ -0,0 +1,2 @@
+import type { CbLine } from "./index.types";
+export declare const cbLine: () => CbLine;

package/dist/line/cb-line.impl.js

@@ -0,0 +1,90 @@
+"use strict";
+// ~~console.log(__filename);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cbLine = void 0;
+class CbLineImpl {
+    constructor() {
+        this._lines = [];
+    }
+    /**
+     * Add line for normal, marked, or optional with padding or without padding
+     * */
+    _add(mark, parts, optional) {
+        if (parts.length < 1) {
+            return this;
+        }
+        let filledParts = parts.filter(p => p !== undefined);
+        if (optional) {
+            filledParts = filledParts.map((p) => p.trim()).filter(p => p !== '');
+        }
+        this._lines.push({ mark, content: filledParts.join(' ') });
+        return this;
+    }
+    /** @inheritDoc */
+    marked(mark, ...parts) {
+        if (typeof mark !== 'string') {
+            return this._add(undefined, parts, false);
+        }
+        return this._add(mark, parts, false);
+    }
+    /** @inheritDoc */
+    add(...parts) {
+        return this._add(undefined, parts, false);
+    }
+    /** @inheritDoc */
+    optional(...parts) {
+        return this._add(undefined, parts, true);
+    }
+    /** @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 */
+    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();
+    }
+}
+const cbLine = () => {
+    return new CbLineImpl();
+};
+exports.cbLine = cbLine;

package/dist/line/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.types';
+export * from './cb-line.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("./cb-line.impl"), exports);

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

@@ -0,0 +1,58 @@
+export interface CbLineItem {
+    mark?: string;
+    content: string;
+}
+export interface CbLine {
+    /**
+     * Add marked line with padding
+     */
+    marked(mark: string, padding: number, ...parts: Array<string>): CbLine;
+    /**
+     * Add marked line
+     */
+    marked(mark: string, ...parts: Array<string>): CbLine;
+    /**
+     * Add line with padding
+     */
+    add(padding: number, ...parts: Array<string>): CbLine;
+    /**
+     * Add line with padding
+     */
+    add(...parts: Array<string>): CbLine;
+    /**
+     * Add optional line with padding
+     */
+    optional(padding: number, ...parts: Array<string>): CbLine;
+    /**
+     * Add optional line
+     */
+    optional(...parts: Array<string>): CbLine;
+    /**
+     * Clear all lines
+     */
+    clear(): CbLine;
+    /**
+     * Add marked line
+     */
+    remove(mark: string): boolean;
+    /**
+     * Replace marked line
+     */
+    replace(mark: string, line: string): boolean;
+    /**
+     * Builds an string from lines
+     */
+    end(): string;
+    /**
+     * Return all lines
+     */
+    get lines(): Array<string>;
+    /**
+     * Return size of lines
+     */
+    get size(): number;
+    /**
+     * Alis for end() method
+     */
+    toString(): string;
+}

package/dist/line/index.types.js

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