@decaf-ts/for-couchdb 0.0.2

package/lib/esm/adapter.js

@@ -0,0 +1,328 @@
+import { Adapter, PersistenceKeys, Operator, GroupOperator, ConnectionError, Repository, } from "@decaf-ts/core";
+import * as Nano from "nano";
+import { CouchDBKeys, reservedAttributes } from "./constants";
+import { BaseError, ConflictError, InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
+import "reflect-metadata";
+import { CouchDBStatement } from "./query/Statement";
+import { Factory } from "./query";
+import { translateOperators } from "./query/translate";
+import { CouchDBSequence } from "./sequences/Sequence";
+import { IndexError } from "./errors";
+import { generateIndexes } from "./indexes/generator";
+export class CouchDBAdapter extends Adapter {
+    constructor(scope, flavour) {
+        super(scope, flavour);
+    }
+    get Clauses() {
+        if (!this.factory)
+            this.factory = new Factory(this);
+        return this.factory;
+    }
+    Query() {
+        return super.Query();
+    }
+    get Statement() {
+        return new CouchDBStatement(this);
+    }
+    parseCondition(condition) {
+        function merge(op, obj1, obj2) {
+            const result = { selector: {} };
+            result.selector[op] = [obj1, obj2];
+            return result;
+        }
+        const { attr1, operator, comparison } = condition;
+        let op = {};
+        if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
+            op[attr1] = {};
+            op[attr1][translateOperators(operator)] =
+                comparison;
+        }
+        else if (operator === Operator.NOT) {
+            op = this.parseCondition(attr1).selector;
+            op[translateOperators(Operator.NOT)] = {};
+            op[translateOperators(Operator.NOT)][attr1.attr1] = comparison;
+        }
+        else {
+            const op1 = this.parseCondition(attr1).selector;
+            const op2 = this.parseCondition(comparison).selector;
+            op = merge(translateOperators(operator), op1, op2).selector;
+        }
+        return { selector: op };
+    }
+    async Sequence(options) {
+        return new CouchDBSequence(options);
+    }
+    async initialize() {
+        const managedModels = Adapter.models(this.flavour);
+        return this.index(...managedModels);
+    }
+    async index(...models) {
+        const indexes = generateIndexes(models);
+        for (const index of indexes) {
+            const res = await this.native.createIndex(index);
+            const { result, id, name } = res;
+            if (result === "existing")
+                throw new ConflictError(`Index for table ${name} with id ${id}`);
+        }
+    }
+    async user() {
+        try {
+            const user = await this.native[CouchDBKeys.NATIVE].session();
+            return user.userCtx.name;
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+    }
+    async raw(rawInput, process = true) {
+        try {
+            const response = await this.native.find(rawInput);
+            if (process)
+                return response.docs;
+            return response;
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+    }
+    async create(tableName, id, model) {
+        const record = {};
+        record[CouchDBKeys.TABLE] = tableName;
+        record[CouchDBKeys.ID] = this.generateId(tableName, id);
+        Object.assign(record, model);
+        let response;
+        try {
+            response = await this.native.insert(record);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        if (!response.ok)
+            throw new InternalError(`Failed to insert doc id: ${id} in table ${tableName}`);
+        Object.defineProperty(model, PersistenceKeys.METADATA, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: response.rev,
+        });
+        return model;
+    }
+    async createAll(tableName, ids, models) {
+        if (ids.length !== models.length)
+            throw new InternalError("Ids and models must have the same length");
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[CouchDBKeys.TABLE] = tableName;
+            record[CouchDBKeys.ID] = this.generateId(tableName, id);
+            Object.assign(record, models[count]);
+            return record;
+        });
+        let response;
+        try {
+            response = await this.native.bulk({ docs: records });
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        if (!response.every((r) => !r.error)) {
+            const errors = response.reduce((accum, el, i) => {
+                if (el.error)
+                    accum.push(`el ${i}: ${el.error}${el.reason ? ` - ${el.reason}` : ""}`);
+                return accum;
+            }, []);
+            throw new InternalError(errors.join("\n"));
+        }
+        models.forEach((m, i) => {
+            Repository.setMetadata(m, response[i].rev);
+            return m;
+        });
+        return models;
+    }
+    async read(tableName, id) {
+        const _id = this.generateId(tableName, id);
+        let record;
+        try {
+            record = await this.native.get(_id);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        Object.defineProperty(record, PersistenceKeys.METADATA, {
+            enumerable: false,
+            writable: false,
+            value: record._rev,
+        });
+        return record;
+    }
+    async update(tableName, id, model) {
+        const record = {};
+        record[CouchDBKeys.TABLE] = tableName;
+        record[CouchDBKeys.ID] = this.generateId(tableName, id);
+        const rev = model[PersistenceKeys.METADATA];
+        if (!rev)
+            throw new InternalError(`No revision number found for record with id ${id}`);
+        Object.assign(record, model);
+        record[CouchDBKeys.REV] = rev;
+        let response;
+        try {
+            response = await this.native.insert(record);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        if (!response.ok)
+            throw new InternalError(`Failed to update doc id: ${id} in table ${tableName}`);
+        Object.defineProperty(model, PersistenceKeys.METADATA, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: response.rev,
+        });
+        return model;
+    }
+    async delete(tableName, id) {
+        const _id = this.generateId(tableName, id);
+        let record;
+        try {
+            record = await this.native.get(_id);
+            await this.native.destroy(_id, record._rev);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        Object.defineProperty(record, PersistenceKeys.METADATA, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: record._rev,
+        });
+        return record;
+    }
+    generateId(tableName, id) {
+        return [tableName, id].join(CouchDBKeys.SEPARATOR);
+    }
+    parseError(err, reason) {
+        return CouchDBAdapter.parseError(err, reason);
+    }
+    isReserved(attr) {
+        return !!attr.match(reservedAttributes);
+    }
+    static parseError(err, reason) {
+        if (err instanceof BaseError)
+            return err;
+        let code = "";
+        if (typeof err === "string") {
+            code = err;
+            if (code.match(/already exist|update conflict/g))
+                return new ConflictError(code);
+            if (code.match(/missing|deleted/g))
+                return new NotFoundError(code);
+        }
+        else if (err.code) {
+            code = err.code;
+            reason = reason || err.message;
+        }
+        else if (err.statusCode) {
+            code = err.statusCode;
+            reason = reason || err.message;
+        }
+        else {
+            code = err.message;
+        }
+        switch (code.toString()) {
+            case "401":
+            case "412":
+            case "409":
+                return new ConflictError(reason);
+            case "404":
+                return new NotFoundError(reason);
+            case "400":
+                if (code.toString().match(/No\sindex\sexists/g))
+                    return new IndexError(err);
+                return new InternalError(err);
+            default:
+                if (code.toString().match(/ECONNREFUSED/g))
+                    return new ConnectionError(err);
+                return new InternalError(err);
+        }
+    }
+    static connect(user, pass, host = "localhost:5984", protocol = "http") {
+        return Nano(`${protocol}://${user}:${pass}@${host}`);
+    }
+    static async createDatabase(con, name) {
+        let result;
+        try {
+            result = await con.db.create(name);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        const { ok, error, reason } = result;
+        if (!ok)
+            throw this.parseError(error, reason);
+    }
+    static async deleteDatabase(con, name) {
+        let result;
+        try {
+            result = await con.db.destroy(name);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        const { ok } = result;
+        if (!ok)
+            throw new InternalError(`Failed to delete database with name ${name}`);
+    }
+    static async createUser(con, dbName, user, pass, roles = ["reader", "writer"]) {
+        const users = await con.db.use("_users");
+        const usr = {
+            _id: "org.couchdb.user:" + user,
+            name: user,
+            password: pass,
+            roles: roles,
+            type: "user",
+        };
+        try {
+            const created = await users.insert(usr);
+            const { ok } = created;
+            if (!ok)
+                throw new InternalError(`Failed to create user ${user}`);
+            const security = await con.request({
+                db: dbName,
+                method: "put",
+                path: "_security",
+                // headers: {
+                //
+                // },
+                body: {
+                    admins: {
+                        names: [user],
+                        roles: [],
+                    },
+                    members: {
+                        names: [user],
+                        roles: roles,
+                    },
+                },
+            });
+            if (!security.ok)
+                throw new InternalError(`Failed to authorize user ${user} to db ${dbName}`);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+    }
+    static async deleteUser(con, dbName, user) {
+        const users = await con.db.use("_users");
+        const id = "org.couchdb.user:" + user;
+        try {
+            const usr = await users.get(id);
+            await users.destroy(id, usr._rev);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/adapter.ts"],"names":[],"mappings":"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","file":"adapter.js","sourcesContent":["import {\n  Adapter,\n  Sequence,\n  SequenceOptions,\n  PersistenceKeys,\n  Operator,\n  GroupOperator,\n  Statement,\n  Query,\n  ClauseFactory,\n  Condition,\n  ConnectionError,\n  Repository,\n} from \"@decaf-ts/core\";\nimport {\n  MangoQuery,\n  DocumentScope,\n  DocumentInsertResponse,\n  DocumentGetResponse,\n  ServerScope,\n  DatabaseCreateResponse,\n  MaybeDocument,\n  MangoResponse,\n  MangoSelector,\n  DocumentBulkResponse,\n  MangoOperator,\n  DatabaseSessionResponse,\n  CreateIndexRequest,\n} from \"nano\";\nimport * as Nano from \"nano\";\nimport { CouchDBKeys, reservedAttributes } from \"./constants\";\nimport {\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport \"reflect-metadata\";\nimport { CouchDBStatement } from \"./query/Statement\";\nimport { Factory } from \"./query\";\nimport { translateOperators } from \"./query/translate\";\nimport { CouchDBSequence } from \"./sequences/Sequence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { IndexError } from \"./errors\";\nimport { generateIndexes } from \"./indexes/generator\";\n\nexport class CouchDBAdapter extends Adapter<DocumentScope<any>, MangoQuery> {\n  private factory?: Factory;\n\n  constructor(scope: DocumentScope<any>, flavour: string) {\n    super(scope, flavour);\n  }\n\n  get Clauses(): ClauseFactory<DocumentScope<any>, MangoQuery> {\n    if (!this.factory) this.factory = new Factory(this);\n    return this.factory;\n  }\n\n  Query<M extends Model>(): Query<MangoQuery, M> {\n    return super.Query();\n  }\n\n  get Statement(): Statement<MangoQuery> {\n    return new CouchDBStatement(this);\n  }\n\n  parseCondition(condition: Condition): MangoQuery {\n    function merge(\n      op: MangoOperator,\n      obj1: MangoSelector,\n      obj2: MangoSelector\n    ): MangoQuery {\n      const result: MangoQuery = { selector: {} as MangoSelector };\n      result.selector[op] = [obj1, obj2];\n      return result;\n    }\n\n    const { attr1, operator, comparison } = condition as unknown as {\n      attr1: string | Condition;\n      operator: Operator | GroupOperator;\n      comparison: any;\n    };\n\n    let op: MangoSelector = {} as MangoSelector;\n    if (\n      [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n        operator as GroupOperator\n      ) === -1\n    ) {\n      op[attr1 as string] = {} as MangoSelector;\n      (op[attr1 as string] as MangoSelector)[translateOperators(operator)] =\n        comparison;\n    } else if (operator === Operator.NOT) {\n      op = this.parseCondition(attr1 as Condition).selector as MangoSelector;\n      op[translateOperators(Operator.NOT)] = {} as MangoSelector;\n      (op[translateOperators(Operator.NOT)] as MangoSelector)[\n        (attr1 as unknown as { attr1: string }).attr1\n      ] = comparison;\n    } else {\n      const op1: any = this.parseCondition(attr1 as Condition).selector;\n      const op2: any = this.parseCondition(comparison as Condition).selector;\n      op = merge(translateOperators(operator), op1, op2).selector;\n    }\n\n    return { selector: op };\n  }\n\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new CouchDBSequence(options);\n  }\n\n  async initialize(): Promise<void> {\n    const managedModels = Adapter.models(this.flavour);\n    return this.index(...managedModels);\n  }\n\n  async index<M extends Model>(...models: Constructor<M>[]): Promise<any> {\n    const indexes: CreateIndexRequest[] = generateIndexes(models);\n    for (const index of indexes) {\n      const res = await this.native.createIndex(index);\n      const { result, id, name } = res;\n      if (result === \"existing\")\n        throw new ConflictError(`Index for table ${name} with id ${id}`);\n    }\n  }\n\n  async user() {\n    try {\n      const user: DatabaseSessionResponse = await (\n        (this.native as any)[CouchDBKeys.NATIVE] as ServerScope\n      ).session();\n      return user.userCtx.name;\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  async raw<V>(rawInput: MangoQuery, process = true): Promise<V> {\n    try {\n      const response: MangoResponse<V> = await this.native.find(rawInput);\n      if (process) return response.docs as V;\n      return response as V;\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    let response: DocumentInsertResponse;\n    try {\n      response = await this.native.insert(record);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n\n    if (!response.ok)\n      throw new InternalError(\n        `Failed to insert doc id: ${id} in table ${tableName}`\n      );\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: response.rev,\n    });\n    return model;\n  }\n\n  async createAll(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[]\n  ): Promise<Record<string, any>[]> {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    let response: DocumentBulkResponse[];\n    try {\n      response = await this.native.bulk({ docs: records });\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    if (!response.every((r) => !r.error)) {\n      const errors = response.reduce((accum: string[], el, i) => {\n        if (el.error)\n          accum.push(\n            `el ${i}: ${el.error}${el.reason ? ` - ${el.reason}` : \"\"}`\n          );\n        return accum;\n      }, []);\n      throw new InternalError(errors.join(\"\\n\"));\n    }\n\n    models.forEach((m, i) => {\n      Repository.setMetadata(m as any, response[i].rev);\n      return m;\n    });\n    return models;\n  }\n\n  async read(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    const _id = this.generateId(tableName, id);\n    let record: DocumentGetResponse;\n    try {\n      record = await this.native.get(_id);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    Object.defineProperty(record, PersistenceKeys.METADATA, {\n      enumerable: false,\n      writable: false,\n      value: record._rev,\n    });\n    return record;\n  }\n\n  async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    const rev = model[PersistenceKeys.METADATA];\n    if (!rev)\n      throw new InternalError(\n        `No revision number found for record with id ${id}`\n      );\n    Object.assign(record, model);\n    record[CouchDBKeys.REV] = rev;\n    let response: DocumentInsertResponse;\n    try {\n      response = await this.native.insert(record);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n\n    if (!response.ok)\n      throw new InternalError(\n        `Failed to update doc id: ${id} in table ${tableName}`\n      );\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: response.rev,\n    });\n    return model;\n  }\n\n  async delete(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    const _id = this.generateId(tableName, id);\n    let record: DocumentGetResponse;\n    try {\n      record = await this.native.get(_id);\n      await this.native.destroy(_id, record._rev);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    Object.defineProperty(record, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: false,\n      writable: false,\n      value: record._rev,\n    });\n    return record;\n  }\n\n  private generateId(tableName: string, id: string | number) {\n    return [tableName, id].join(CouchDBKeys.SEPARATOR);\n  }\n\n  protected parseError(err: Error | string, reason?: string): BaseError {\n    return CouchDBAdapter.parseError(err, reason);\n  }\n\n  protected isReserved(attr: string): boolean {\n    return !!attr.match(reservedAttributes);\n  }\n\n  protected static parseError(err: Error | string, reason?: string): BaseError {\n    if (err instanceof BaseError) return err as any;\n    let code: string = \"\";\n    if (typeof err === \"string\") {\n      code = err;\n      if (code.match(/already exist|update conflict/g))\n        return new ConflictError(code);\n      if (code.match(/missing|deleted/g)) return new NotFoundError(code);\n    } else if ((err as any).code) {\n      code = (err as any).code;\n      reason = reason || err.message;\n    } else if ((err as any).statusCode) {\n      code = (err as any).statusCode;\n      reason = reason || err.message;\n    } else {\n      code = err.message;\n    }\n\n    switch (code.toString()) {\n      case \"401\":\n      case \"412\":\n      case \"409\":\n        return new ConflictError(reason as string);\n      case \"404\":\n        return new NotFoundError(reason as string);\n      case \"400\":\n        if (code.toString().match(/No\\sindex\\sexists/g))\n          return new IndexError(err);\n        return new InternalError(err);\n      default:\n        if (code.toString().match(/ECONNREFUSED/g))\n          return new ConnectionError(err);\n        return new InternalError(err);\n    }\n  }\n\n  static connect(\n    user: string,\n    pass: string,\n    host = \"localhost:5984\",\n    protocol: \"http\" | \"https\" = \"http\"\n  ): ServerScope {\n    return Nano(`${protocol}://${user}:${pass}@${host}`);\n  }\n\n  static async createDatabase(con: ServerScope, name: string) {\n    let result: DatabaseCreateResponse;\n    try {\n      result = await con.db.create(name);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    const { ok, error, reason } = result;\n    if (!ok) throw this.parseError(error as string, reason);\n  }\n\n  static async deleteDatabase(con: ServerScope, name: string) {\n    let result;\n    try {\n      result = await con.db.destroy(name);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n    const { ok } = result;\n    if (!ok)\n      throw new InternalError(`Failed to delete database with name ${name}`);\n  }\n\n  static async createUser(\n    con: ServerScope,\n    dbName: string,\n    user: string,\n    pass: string,\n    roles: string[] = [\"reader\", \"writer\"]\n  ) {\n    const users = await con.db.use(\"_users\");\n    const usr = {\n      _id: \"org.couchdb.user:\" + user,\n      name: user,\n      password: pass,\n      roles: roles,\n      type: \"user\",\n    };\n    try {\n      const created: DocumentInsertResponse = await users.insert(\n        usr as MaybeDocument\n      );\n      const { ok } = created;\n      if (!ok) throw new InternalError(`Failed to create user ${user}`);\n      const security: any = await con.request({\n        db: dbName,\n        method: \"put\",\n        path: \"_security\",\n        // headers: {\n        //\n        // },\n        body: {\n          admins: {\n            names: [user],\n            roles: [],\n          },\n          members: {\n            names: [user],\n            roles: roles,\n          },\n        },\n      });\n      if (!security.ok)\n        throw new InternalError(\n          `Failed to authorize user ${user} to db ${dbName}`\n        );\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n\n  static async deleteUser(con: ServerScope, dbName: string, user: string) {\n    const users = await con.db.use(\"_users\");\n    const id = \"org.couchdb.user:\" + user;\n    try {\n      const usr = await users.get(id);\n      await users.destroy(id, usr._rev);\n    } catch (e: any) {\n      throw this.parseError(e);\n    }\n  }\n}\n"]}

package/lib/esm/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const reservedAttributes: RegExp;
+export declare const CouchDBKeys: {
+    SEPARATOR: string;
+    ID: string;
+    REV: string;
+    TABLE: string;
+    DDOC: string;
+    NATIVE: string;
+    INDEX: string;
+};

package/lib/esm/constants.js

@@ -0,0 +1,12 @@
+export const reservedAttributes = /^_.*$/g;
+export const CouchDBKeys = {
+    SEPARATOR: "_",
+    ID: "_id",
+    REV: "_rev",
+    TABLE: "??table",
+    DDOC: "ddoc",
+    NATIVE: "__native",
+    INDEX: "index",
+};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsUUFBUSxDQUFDO0FBRTNDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRztJQUN6QixTQUFTLEVBQUUsR0FBRztJQUNkLEVBQUUsRUFBRSxLQUFLO0lBQ1QsR0FBRyxFQUFFLE1BQU07SUFDWCxLQUFLLEVBQUUsU0FBUztJQUNoQixJQUFJLEVBQUUsTUFBTTtJQUNaLE1BQU0sRUFBRSxVQUFVO0lBQ2xCLEtBQUssRUFBRSxPQUFPO0NBQ2YsQ0FBQyIsImZpbGUiOiJjb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgcmVzZXJ2ZWRBdHRyaWJ1dGVzID0gL15fLiokL2c7XG5cbmV4cG9ydCBjb25zdCBDb3VjaERCS2V5cyA9IHtcbiAgU0VQQVJBVE9SOiBcIl9cIixcbiAgSUQ6IFwiX2lkXCIsXG4gIFJFVjogXCJfcmV2XCIsXG4gIFRBQkxFOiBcIj8/dGFibGVcIixcbiAgRERPQzogXCJkZG9jXCIsXG4gIE5BVElWRTogXCJfX25hdGl2ZVwiLFxuICBJTkRFWDogXCJpbmRleFwiLFxufTtcbiJdfQ==

package/lib/esm/errors.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export declare class IndexError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/esm/errors.js

@@ -0,0 +1,8 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export class IndexError extends BaseError {
+    constructor(msg) {
+        super(IndexError.name, msg);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXBELE1BQU0sT0FBTyxVQUFXLFNBQVEsU0FBUztJQUN2QyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQzlCLENBQUM7Q0FDRiIsImZpbGUiOiJlcnJvcnMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlRXJyb3IgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuZXhwb3J0IGNsYXNzIEluZGV4RXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZyB8IEVycm9yKSB7XG4gICAgc3VwZXIoSW5kZXhFcnJvci5uYW1lLCBtc2cpO1xuICB9XG59XG4iXX0=

package/lib/esm/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./model";
+export * from "./sequences";
+export * from "./adapter";
+export * from "./constants";
+export * from "./errors";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module ts-workspace
+ */
+/**
+ * @summary Namespace summary
+ * @description Namespace description
+ * @namespace Namespace
+ * @memberOf module:ts-workspace
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+export declare const VERSION = "0.0.1";

package/lib/esm/index.js

@@ -0,0 +1,26 @@
+export * from "./model";
+export * from "./sequences";
+export * from "./adapter";
+export * from "./constants";
+export * from "./errors";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module ts-workspace
+ */
+/**
+ * @summary Namespace summary
+ * @description Namespace description
+ * @namespace Namespace
+ * @memberOf module:ts-workspace
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+export const VERSION = "0.0.1";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFNBQVMsQ0FBQztBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7O0dBS0c7QUFFSDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2VxdWVuY2VzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hZGFwdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBNb2R1bGUgc3VtbWFyeVxuICogQGRlc2NyaXB0aW9uIE1vZHVsZSBkZXNjcmlwdGlvblxuICogQG1vZHVsZSB0cy13b3Jrc3BhY2VcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IE5hbWVzcGFjZSBzdW1tYXJ5XG4gKiBAZGVzY3JpcHRpb24gTmFtZXNwYWNlIGRlc2NyaXB0aW9uXG4gKiBAbmFtZXNwYWNlIE5hbWVzcGFjZVxuICogQG1lbWJlck9mIG1vZHVsZTp0cy13b3Jrc3BhY2VcbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IHN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb25cbiAqIEBkZXNjcmlwdGlvbiB0aGlzIGlzIGhvdyB5b3Ugc2hvdWxkIGRvY3VtZW50IGEgY29uc3RhbnRcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiMC4wLjFcIjtcbiJdfQ==

package/lib/esm/indexes/generator.d.ts

@@ -0,0 +1,3 @@
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { CreateIndexRequest } from "nano";
+export declare function generateIndexes<M extends Model>(models: Constructor<M>[]): CreateIndexRequest[];

package/lib/esm/indexes/generator.js

@@ -0,0 +1,72 @@
+import { PersistenceKeys, Repository, } from "@decaf-ts/core";
+import { CouchDBKeys } from "../constants";
+import { DefaultSeparator } from "@decaf-ts/db-decorators";
+import { CouchDBOperator } from "../query/constants";
+function generateIndexName(name, direction, compositions, separator = DefaultSeparator) {
+    return [
+        ...name.map((n) => (n === CouchDBKeys.TABLE ? "table" : n)),
+        ...(compositions || []),
+        ...(direction ? [direction] : []),
+        CouchDBKeys.INDEX,
+    ].join(separator);
+}
+export function generateIndexes(models) {
+    const tableName = generateIndexName([CouchDBKeys.TABLE]);
+    const indexes = {};
+    indexes[tableName] = {
+        index: {
+            fields: [CouchDBKeys.TABLE],
+        },
+        name: tableName,
+        ddoc: tableName,
+        type: "json",
+    };
+    models.forEach((m) => {
+        const ind = Repository.indexes(m);
+        Object.entries(ind).forEach(([key, value]) => {
+            const k = Object.keys(value)[0];
+            // eslint-disable-next-line prefer-const
+            let { directions, compositions } = value[k];
+            const tableName = Repository.table(m);
+            compositions = compositions || [];
+            function generate(sort) {
+                const name = [
+                    tableName,
+                    key,
+                    ...compositions,
+                    PersistenceKeys.INDEX,
+                ].join(DefaultSeparator);
+                indexes[name] = {
+                    index: {
+                        fields: [key, ...compositions, CouchDBKeys.TABLE].reduce((accum, el) => {
+                            if (sort) {
+                                const res = {};
+                                res[el] = sort;
+                                accum.push(res);
+                            }
+                            else {
+                                accum.push(el);
+                            }
+                            return accum;
+                        }, []),
+                    },
+                    name: name,
+                    ddoc: name,
+                    type: "json",
+                };
+                if (!sort) {
+                    const tableFilter = {};
+                    tableFilter[CouchDBKeys.TABLE] = {};
+                    tableFilter[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;
+                    indexes[name].index.partial_filter_selector = tableFilter;
+                }
+            }
+            generate();
+            if (directions)
+                directions.forEach((d) => generate(d));
+        });
+    });
+    return Object.values(indexes);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/indexes/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./generator";
+export * from "./types";

package/lib/esm/indexes/index.js

@@ -0,0 +1,4 @@
+export * from "./generator";
+export * from "./types";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFDIiwiZmlsZSI6ImluZGV4ZXMvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9nZW5lcmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4iXX0=

package/lib/esm/indexes/types.d.ts

@@ -0,0 +1,11 @@
+import { OrderDirection } from "@decaf-ts/core";
+export type Index = {
+    index: {
+        fields: string[] | {
+            [k: string]: OrderDirection;
+        };
+    };
+    ddoc?: string;
+    name: string;
+    type: "json";
+};

package/lib/esm/indexes/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleGVzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoiaW5kZXhlcy90eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9yZGVyRGlyZWN0aW9uIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5cbmV4cG9ydCB0eXBlIEluZGV4ID0ge1xuICBpbmRleDoge1xuICAgIGZpZWxkczogc3RyaW5nW10gfCB7IFtrOiBzdHJpbmddOiBPcmRlckRpcmVjdGlvbiB9O1xuICB9O1xuICBkZG9jPzogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIHR5cGU6IFwianNvblwiO1xufTtcbiJdfQ==

package/lib/esm/interfaces/CouchDBRepository.d.ts

@@ -0,0 +1,7 @@
+import { Repository } from "@decaf-ts/core";
+import { MangoQuery } from "nano";
+import { CouchDBAdapter } from "../adapter";
+import { Model } from "@decaf-ts/decorator-validation";
+export interface CouchDBRepository<M extends Model> extends Repository<M, MangoQuery> {
+    adapter: CouchDBAdapter;
+}

package/lib/esm/interfaces/CouchDBRepository.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbnRlcmZhY2VzL0NvdWNoREJSZXBvc2l0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoiaW50ZXJmYWNlcy9Db3VjaERCUmVwb3NpdG9yeS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcG9zaXRvcnkgfSBmcm9tIFwiQGRlY2FmLXRzL2NvcmVcIjtcbmltcG9ydCB7IE1hbmdvUXVlcnkgfSBmcm9tIFwibmFub1wiO1xuaW1wb3J0IHsgQ291Y2hEQkFkYXB0ZXIgfSBmcm9tIFwiLi4vYWRhcHRlclwiO1xuaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ291Y2hEQlJlcG9zaXRvcnk8TSBleHRlbmRzIE1vZGVsPlxuICBleHRlbmRzIFJlcG9zaXRvcnk8TSwgTWFuZ29RdWVyeT4ge1xuICBhZGFwdGVyOiBDb3VjaERCQWRhcHRlcjtcbn1cbiJdfQ==

package/lib/esm/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from "./CouchDBRepository";

package/lib/esm/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from "./CouchDBRepository";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUMiLCJmaWxlIjoiaW50ZXJmYWNlcy9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0NvdWNoREJSZXBvc2l0b3J5XCI7XG4iXX0=

package/lib/esm/model/CouchDBSequence.d.ts

@@ -0,0 +1,20 @@
+import { ModelArg } from "@decaf-ts/decorator-validation";
+import { BaseModel } from "@decaf-ts/core";
+export declare class Sequence extends BaseModel {
+    /**
+     * @summary the Primary key for the DBSequence
+     * @prop name
+     *
+     * @see pk
+     */
+    id?: string;
+    /**
+     * @summary the current value for the DBSequence
+     * @prop current
+     *
+     * @see required
+     * @see index
+     */
+    current?: string | number;
+    constructor(seq?: ModelArg<Sequence>);
+}