@decaf-ts/for-pouch 0.0.2

package/lib/adapter.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PouchAdapter = void 0;
+require("reflect-metadata");
+const for_couchdb_1 = require("@decaf-ts/for-couchdb");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const core_1 = require("@decaf-ts/core");
+class PouchAdapter extends for_couchdb_1.CouchDBAdapter {
+    constructor(scope, flavour = "pouch") {
+        super(scope, flavour);
+    }
+    async user() {
+        const url = this.native.server.name;
+        if (url) {
+            const regexp = /https?:\/\/(.+?):.+?@/g;
+            const m = regexp.exec(url);
+            if (m) {
+                return new core_1.User({
+                    id: m[1],
+                });
+            }
+        }
+        throw new db_decorators_1.InternalError("Not implemented");
+    }
+    async readAll(tableName, ids) {
+        const results = await this.native.fetch({ keys: ids.map((id) => this.generateId(tableName, id)) }, {});
+        return results.rows.map((r) => {
+            if (r instanceof Error)
+                throw r;
+            const res = Object.assign({}, r);
+            Object.defineProperty(res, core_1.PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                value: r[for_couchdb_1.CouchDBKeys.REV],
+            });
+            return res;
+        });
+    }
+    async deleteAll(tableName, ids) {
+        const results = await this.native.fetch({ keys: ids.map((id) => this.generateId(tableName, id)) }, {});
+        const deletion = await this.native.bulk({
+            docs: results.rows.map((r) => {
+                r[for_couchdb_1.CouchDBKeys.DELETED] = true;
+                return r;
+            }),
+        });
+        deletion.forEach((d) => {
+            if (d.error)
+                console.error(d.error);
+        });
+        return results.rows.map((r) => {
+            if (r instanceof Error)
+                throw r;
+            const res = Object.assign({}, r);
+            Object.defineProperty(res, core_1.PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                value: r[for_couchdb_1.CouchDBKeys.REV],
+            });
+            return res;
+        });
+    }
+    parseError(err, reason) {
+        return PouchAdapter.parseError(err, reason);
+    }
+    static parseError(err, reason) {
+        // return super.parseError(err, reason);
+        if (err instanceof db_decorators_1.BaseError)
+            return err;
+        let code = "";
+        if (typeof err === "string") {
+            code = err;
+            if (code.match(/already exist|update conflict/g))
+                return new db_decorators_1.ConflictError(code);
+            if (code.match(/missing|deleted/g))
+                return new db_decorators_1.NotFoundError(code);
+        }
+        else if (err.status) {
+            code = err.status;
+            reason = reason || err.message;
+        }
+        else {
+            code = err.message;
+        }
+        switch (code.toString()) {
+            case "401":
+            case "412":
+            case "409":
+                return new db_decorators_1.ConflictError(reason);
+            case "404":
+                return new db_decorators_1.NotFoundError(reason);
+            case "400":
+                if (code.toString().match(/No\sindex\sexists/g))
+                    return new for_couchdb_1.IndexError(err);
+                return new db_decorators_1.InternalError(err);
+            default:
+                if (code.toString().match(/ECONNREFUSED/g))
+                    return new core_1.ConnectionError(err);
+                return new db_decorators_1.InternalError(err);
+        }
+    }
+}
+exports.PouchAdapter = PouchAdapter;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/adapter.ts"],"names":[],"mappings":"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","file":"adapter.js","sourcesContent":["import \"reflect-metadata\";\nimport {\n  CouchDBAdapter,\n  CouchDBKeys,\n  DocumentBulkResponse,\n  DocumentScope,\n  IndexError,\n} from \"@decaf-ts/for-couchdb\";\nimport {\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { ConnectionError, PersistenceKeys, User } from \"@decaf-ts/core\";\n\nexport class PouchAdapter extends CouchDBAdapter {\n  constructor(scope: DocumentScope<any>, flavour: string = \"pouch\") {\n    super(scope, flavour);\n  }\n\n  async user(): Promise<User> {\n    const url = (this.native.server as unknown as { name: string }).name;\n    if (url) {\n      const regexp = /https?:\\/\\/(.+?):.+?@/g;\n      const m = regexp.exec(url);\n      if (m) {\n        return new User({\n          id: m[1],\n        });\n      }\n    }\n    throw new InternalError(\"Not implemented\");\n  }\n\n  async readAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]> {\n    const results = await this.native.fetch(\n      { keys: ids.map((id) => this.generateId(tableName, id as any)) },\n      {}\n    );\n    return results.rows.map((r) => {\n      if (r instanceof Error) throw r;\n      const res = Object.assign({}, r);\n      Object.defineProperty(res, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        value: (r as any)[CouchDBKeys.REV],\n      });\n      return res;\n    });\n  }\n\n  async deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]> {\n    const results = await this.native.fetch(\n      { keys: ids.map((id) => this.generateId(tableName, id as any)) },\n      {}\n    );\n    const deletion: DocumentBulkResponse[] = await this.native.bulk({\n      docs: results.rows.map((r) => {\n        (r as any)[CouchDBKeys.DELETED] = true;\n        return r;\n      }),\n    });\n    deletion.forEach((d: DocumentBulkResponse) => {\n      if (d.error) console.error(d.error);\n    });\n    return results.rows.map((r) => {\n      if (r instanceof Error) throw r;\n      const res = Object.assign({}, r);\n      Object.defineProperty(res, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        value: (r as any)[CouchDBKeys.REV],\n      });\n      return res;\n    });\n  }\n\n  parseError(err: Error | string, reason?: string): BaseError {\n    return PouchAdapter.parseError(err, reason);\n  }\n\n  static parseError(err: Error | string, reason?: string): BaseError {\n    // return super.parseError(err, reason);\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).status) {\n      code = (err as any).status;\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"]}

package/lib/adapter.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+import { CouchDBAdapter, DocumentScope } from "@decaf-ts/for-couchdb";
+import { BaseError } from "@decaf-ts/db-decorators";
+import { User } from "@decaf-ts/core";
+export declare class PouchAdapter extends CouchDBAdapter {
+    constructor(scope: DocumentScope<any>, flavour?: string);
+    user(): Promise<User>;
+    readAll(tableName: string, ids: (string | number | bigint)[]): Promise<Record<string, any>[]>;
+    deleteAll(tableName: string, ids: (string | number | bigint)[]): Promise<Record<string, any>[]>;
+    parseError(err: Error | string, reason?: string): BaseError;
+    static parseError(err: Error | string, reason?: string): BaseError;
+}

package/lib/esm/PouchRepository.d.ts

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

package/lib/esm/PouchRepository.js

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

package/lib/esm/adapter.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+import { CouchDBAdapter, DocumentScope } from "@decaf-ts/for-couchdb";
+import { BaseError } from "@decaf-ts/db-decorators";
+import { User } from "@decaf-ts/core";
+export declare class PouchAdapter extends CouchDBAdapter {
+    constructor(scope: DocumentScope<any>, flavour?: string);
+    user(): Promise<User>;
+    readAll(tableName: string, ids: (string | number | bigint)[]): Promise<Record<string, any>[]>;
+    deleteAll(tableName: string, ids: (string | number | bigint)[]): Promise<Record<string, any>[]>;
+    parseError(err: Error | string, reason?: string): BaseError;
+    static parseError(err: Error | string, reason?: string): BaseError;
+}

package/lib/esm/adapter.js

@@ -0,0 +1,101 @@
+import "reflect-metadata";
+import { CouchDBAdapter, CouchDBKeys, IndexError, } from "@decaf-ts/for-couchdb";
+import { BaseError, ConflictError, InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
+import { ConnectionError, PersistenceKeys, User } from "@decaf-ts/core";
+export class PouchAdapter extends CouchDBAdapter {
+    constructor(scope, flavour = "pouch") {
+        super(scope, flavour);
+    }
+    async user() {
+        const url = this.native.server.name;
+        if (url) {
+            const regexp = /https?:\/\/(.+?):.+?@/g;
+            const m = regexp.exec(url);
+            if (m) {
+                return new User({
+                    id: m[1],
+                });
+            }
+        }
+        throw new InternalError("Not implemented");
+    }
+    async readAll(tableName, ids) {
+        const results = await this.native.fetch({ keys: ids.map((id) => this.generateId(tableName, id)) }, {});
+        return results.rows.map((r) => {
+            if (r instanceof Error)
+                throw r;
+            const res = Object.assign({}, r);
+            Object.defineProperty(res, PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                value: r[CouchDBKeys.REV],
+            });
+            return res;
+        });
+    }
+    async deleteAll(tableName, ids) {
+        const results = await this.native.fetch({ keys: ids.map((id) => this.generateId(tableName, id)) }, {});
+        const deletion = await this.native.bulk({
+            docs: results.rows.map((r) => {
+                r[CouchDBKeys.DELETED] = true;
+                return r;
+            }),
+        });
+        deletion.forEach((d) => {
+            if (d.error)
+                console.error(d.error);
+        });
+        return results.rows.map((r) => {
+            if (r instanceof Error)
+                throw r;
+            const res = Object.assign({}, r);
+            Object.defineProperty(res, PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                value: r[CouchDBKeys.REV],
+            });
+            return res;
+        });
+    }
+    parseError(err, reason) {
+        return PouchAdapter.parseError(err, reason);
+    }
+    static parseError(err, reason) {
+        // return super.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.status) {
+            code = err.status;
+            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);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/adapter.ts"],"names":[],"mappings":"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","file":"adapter.js","sourcesContent":["import \"reflect-metadata\";\nimport {\n  CouchDBAdapter,\n  CouchDBKeys,\n  DocumentBulkResponse,\n  DocumentScope,\n  IndexError,\n} from \"@decaf-ts/for-couchdb\";\nimport {\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { ConnectionError, PersistenceKeys, User } from \"@decaf-ts/core\";\n\nexport class PouchAdapter extends CouchDBAdapter {\n  constructor(scope: DocumentScope<any>, flavour: string = \"pouch\") {\n    super(scope, flavour);\n  }\n\n  async user(): Promise<User> {\n    const url = (this.native.server as unknown as { name: string }).name;\n    if (url) {\n      const regexp = /https?:\\/\\/(.+?):.+?@/g;\n      const m = regexp.exec(url);\n      if (m) {\n        return new User({\n          id: m[1],\n        });\n      }\n    }\n    throw new InternalError(\"Not implemented\");\n  }\n\n  async readAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]> {\n    const results = await this.native.fetch(\n      { keys: ids.map((id) => this.generateId(tableName, id as any)) },\n      {}\n    );\n    return results.rows.map((r) => {\n      if (r instanceof Error) throw r;\n      const res = Object.assign({}, r);\n      Object.defineProperty(res, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        value: (r as any)[CouchDBKeys.REV],\n      });\n      return res;\n    });\n  }\n\n  async deleteAll(\n    tableName: string,\n    ids: (string | number | bigint)[]\n  ): Promise<Record<string, any>[]> {\n    const results = await this.native.fetch(\n      { keys: ids.map((id) => this.generateId(tableName, id as any)) },\n      {}\n    );\n    const deletion: DocumentBulkResponse[] = await this.native.bulk({\n      docs: results.rows.map((r) => {\n        (r as any)[CouchDBKeys.DELETED] = true;\n        return r;\n      }),\n    });\n    deletion.forEach((d: DocumentBulkResponse) => {\n      if (d.error) console.error(d.error);\n    });\n    return results.rows.map((r) => {\n      if (r instanceof Error) throw r;\n      const res = Object.assign({}, r);\n      Object.defineProperty(res, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        value: (r as any)[CouchDBKeys.REV],\n      });\n      return res;\n    });\n  }\n\n  parseError(err: Error | string, reason?: string): BaseError {\n    return PouchAdapter.parseError(err, reason);\n  }\n\n  static parseError(err: Error | string, reason?: string): BaseError {\n    // return super.parseError(err, reason);\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).status) {\n      code = (err as any).status;\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"]}

package/lib/esm/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./adapter";
+export * from "./PouchRepository";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module for-nano
+ */
+/**
+ * @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,17 @@
+export * from "./adapter";
+export * from "./PouchRepository";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module for-nano
+ */
+/**
+ * @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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsU0FBUyxDQUFDO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMiLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hZGFwdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9Qb3VjaFJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgTW9kdWxlIHN1bW1hcnlcbiAqIEBkZXNjcmlwdGlvbiBNb2R1bGUgZGVzY3JpcHRpb25cbiAqIEBtb2R1bGUgZm9yLW5hbm9cbiAqL1xuXG4vKipcbiAqIEBzdW1tYXJ5IHN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb25cbiAqIEBkZXNjcmlwdGlvbiB0aGlzIGlzIGhvdyB5b3Ugc2hvdWxkIGRvY3VtZW50IGEgY29uc3RhbnRcbiAqIEBjb25zdCBWRVJTSU9OXG4gKiBAbWVtYmVyT2YgbW9kdWxlOnRzLXdvcmtzcGFjZVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiMC4wLjFcIjtcbiJdfQ==

package/lib/esm/utils.d.ts

@@ -0,0 +1,21 @@
+import Database = PouchDB.Database;
+import { BulkFetchDocsWrapper, BulkModifyDocsWrapper, CreateIndexRequest, CreateIndexResponse, DatabaseAuthResponse, DatabaseSessionResponse, DocumentDestroyResponse, DocumentGetParams, DocumentInsertResponse, DocumentScope, MangoQuery, MangoResponse, ServerScope, DocumentFetchResponse } from "@decaf-ts/for-couchdb";
+export declare function toServerScope(pouch: typeof PouchDB): {
+    pouch: typeof PouchDB;
+    use<D>(db: string): DocumentScope<D>;
+    auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;
+    session(): Promise<DatabaseSessionResponse>;
+};
+export declare function toDocumentScope(database: Database): {
+    db: Database;
+    fetch(docnames: BulkFetchDocsWrapper): Promise<DocumentFetchResponse<any>>;
+    auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;
+    session(): Promise<DatabaseSessionResponse>;
+    insert(document: any): Promise<DocumentInsertResponse>;
+    get(docname: string, params?: DocumentGetParams | undefined): Promise<any>;
+    destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;
+    bulk(docs: BulkModifyDocsWrapper): Promise<DocumentInsertResponse[]>;
+    createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;
+    find(query: MangoQuery): Promise<MangoResponse<any>>;
+    readonly server: ServerScope;
+};

package/lib/esm/utils.js

@@ -0,0 +1,92 @@
+import { InternalError } from "@decaf-ts/db-decorators";
+export function toServerScope(pouch) {
+    return new (class {
+        constructor(pouch) {
+            this.pouch = pouch;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        use(db) {
+            throw new Error("Method not implemented.");
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        auth(username, userpass) {
+            throw new Error("Method not implemented.");
+        }
+        session() {
+            throw new Error("Method not implemented.");
+        }
+    })(pouch);
+}
+export function toDocumentScope(database) {
+    return new (class {
+        constructor(db) {
+            this.db = db;
+        }
+        async fetch(docnames) {
+            const result = await this.db.bulkGet({
+                docs: docnames.keys.map((k) => ({ id: k })),
+            });
+            return {
+                offset: 0,
+                rows: result.results.reduce((accum, r) => {
+                    const docs = r.docs.map((d) => {
+                        if (d["error"])
+                            throw new InternalError(d["error"]);
+                        return d["ok"];
+                    });
+                    accum.push(...docs);
+                    return accum;
+                }, []),
+                total_rows: 0,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        auth(username, userpass) {
+            throw new Error("Method not implemented.");
+        }
+        session() {
+            throw new Error("Method not implemented.");
+        }
+        async insert(document) {
+            return this.db.put(document);
+        }
+        get(docname, params) {
+            return new Promise((resolve, reject) => {
+                this.db.get(docname, params || {}, (err, result) => {
+                    if (err)
+                        return reject(err);
+                    resolve(result);
+                });
+            });
+        }
+        destroy(docname, rev) {
+            return this.db.remove({ _id: docname, _rev: rev });
+        }
+        async bulk(docs) {
+            const results = await this.db.bulkDocs(docs.docs);
+            return results.map((r) => {
+                if (r instanceof Error)
+                    return { ok: false };
+                return Object.assign({
+                    ok: true,
+                }, r);
+            });
+        }
+        async createIndex(indexDef) {
+            const result = await this.db.createIndex(indexDef);
+            return {
+                result: result.result,
+                id: indexDef.ddoc,
+                name: indexDef.name,
+            };
+        }
+        find(query) {
+            return this.db.find(query);
+        }
+        get server() {
+            return this.db;
+        }
+    })(database);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,MAAM,UAAU,aAAa,CAAC,KAAqB;IACjD,OAAO,IAAI,CAAC;QACV,YAAmB,KAAqB;YAArB,UAAK,GAAL,KAAK,CAAgB;QAAG,CAAC;QAE5C,6DAA6D;QAC7D,GAAG,CAAI,EAAU;YACf,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,6DAA6D;QAC7D,IAAI,CAAC,QAAgB,EAAE,QAAgB;YACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO;YACL,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC,CAAC,KAAK,CAAC,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAkB;IAChD,OAAO,IAAI,CAAC;QACV,YAAmB,EAAY;YAAZ,OAAE,GAAF,EAAE,CAAU;QAAG,CAAC;QAEnC,KAAK,CAAC,KAAK,CACT,QAA8B;YAE9B,MAAM,MAAM,GAAyB,MAAM,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC;gBACzD,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;aACpD,CAAC,CAAC;YACH,OAAO;gBACL,MAAM,EAAE,CAAC;gBACT,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAY,EAAE,CAAC,EAAE,EAAE;oBAC9C,MAAM,IAAI,GAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;wBACnC,IAAK,CAAS,CAAC,OAAO,CAAC;4BACrB,MAAM,IAAI,aAAa,CAAE,CAAS,CAAC,OAAO,CAAC,CAAC,CAAC;wBAC/C,OAAQ,CAAS,CAAC,IAAI,CAAQ,CAAC;oBACjC,CAAC,CAAC,CAAC;oBACH,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;oBACpB,OAAO,KAAK,CAAC;gBACf,CAAC,EAAE,EAAE,CAAC;gBACN,UAAU,EAAE,CAAC;aACd,CAAC;QACJ,CAAC;QAED,6DAA6D;QAC7D,IAAI,CAAC,QAAgB,EAAE,QAAgB;YACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO;YACL,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,KAAK,CAAC,MAAM,CAAC,QAAa;YACxB,OAAO,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC/B,CAAC;QACD,GAAG,CAAC,OAAe,EAAE,MAAsC;YACzD,OAAO,IAAI,OAAO,CAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC1C,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;oBACjD,IAAI,GAAG;wBAAE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;oBAC5B,OAAO,CAAC,MAAM,CAAC,CAAC;gBAClB,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,CAAC,OAAe,EAAE,GAAW;YAClC,OAAO,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,IAA2B;YACpC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACvB,IAAI,CAAC,YAAY,KAAK;oBAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;gBAC7C,OAAO,MAAM,CAAC,MAAM,CAClB;oBACE,EAAE,EAAE,IAAI;iBACT,EACD,CAAC,CACF,CAAC;YACJ,CAAC,CAA6B,CAAC;QACjC,CAAC;QACD,KAAK,CAAC,WAAW,CACf,QAA4B;YAE5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,QAAe,CAAC,CAAC;YAC1D,OAAO;gBACL,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,EAAE,EAAE,QAAQ,CAAC,IAAc;gBAC3B,IAAI,EAAE,QAAQ,CAAC,IAAc;aAC9B,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,KAAiB;YACpB,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAoC,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,MAAM;YACR,OAAO,IAAI,CAAC,EAA4B,CAAC;QAC3C,CAAC;KACF,CAAC,CAAC,QAAQ,CAAC,CAAC;AACf,CAAC","file":"utils.js","sourcesContent":["import Database = PouchDB.Database;\nimport {\n  BulkFetchDocsWrapper,\n  BulkModifyDocsWrapper,\n  CreateIndexRequest,\n  CreateIndexResponse,\n  DatabaseAuthResponse,\n  DatabaseSessionResponse,\n  DocumentDestroyResponse,\n  DocumentGetParams,\n  DocumentInsertResponse,\n  DocumentScope,\n  MangoQuery,\n  MangoResponse,\n  ServerScope,\n  DocumentFetchResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport FindRequest = PouchDB.Find.FindRequest;\nimport BulkGetResponse = PouchDB.Core.BulkGetResponse;\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\nexport function toServerScope(pouch: typeof PouchDB) {\n  return new (class implements ServerScope {\n    constructor(public pouch: typeof PouchDB) {}\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    use<D>(db: string): DocumentScope<D> {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    auth(username: string, userpass: string): Promise<DatabaseAuthResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    session(): Promise<DatabaseSessionResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n  })(pouch);\n}\n\nexport function toDocumentScope(database: Database) {\n  return new (class implements DocumentScope<any> {\n    constructor(public db: Database) {}\n\n    async fetch(\n      docnames: BulkFetchDocsWrapper\n    ): Promise<DocumentFetchResponse<any>> {\n      const result: BulkGetResponse<any> = await this.db.bulkGet({\n        docs: docnames.keys.map((k: string) => ({ id: k })),\n      });\n      return {\n        offset: 0,\n        rows: result.results.reduce((accum: any[], r) => {\n          const docs: any[] = r.docs.map((d) => {\n            if ((d as any)[\"error\"])\n              throw new InternalError((d as any)[\"error\"]);\n            return (d as any)[\"ok\"] as any;\n          });\n          accum.push(...docs);\n          return accum;\n        }, []),\n        total_rows: 0,\n      };\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    auth(username: string, userpass: string): Promise<DatabaseAuthResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n    session(): Promise<DatabaseSessionResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n    async insert(document: any): Promise<DocumentInsertResponse> {\n      return this.db.put(document);\n    }\n    get(docname: string, params?: DocumentGetParams | undefined): Promise<any> {\n      return new Promise<any>((resolve, reject) => {\n        this.db.get(docname, params || {}, (err, result) => {\n          if (err) return reject(err);\n          resolve(result);\n        });\n      });\n    }\n    destroy(docname: string, rev: string): Promise<DocumentDestroyResponse> {\n      return this.db.remove({ _id: docname, _rev: rev });\n    }\n    async bulk(docs: BulkModifyDocsWrapper): Promise<DocumentInsertResponse[]> {\n      const results = await this.db.bulkDocs(docs.docs);\n      return results.map((r) => {\n        if (r instanceof Error) return { ok: false };\n        return Object.assign(\n          {\n            ok: true,\n          },\n          r\n        );\n      }) as DocumentInsertResponse[];\n    }\n    async createIndex(\n      indexDef: CreateIndexRequest\n    ): Promise<CreateIndexResponse> {\n      const result = await this.db.createIndex(indexDef as any);\n      return {\n        result: result.result,\n        id: indexDef.ddoc as string,\n        name: indexDef.name as string,\n      };\n    }\n    find(query: MangoQuery): Promise<MangoResponse<any>> {\n      return this.db.find(query as unknown as FindRequest<any>);\n    }\n    get server() {\n      return this.db as unknown as ServerScope;\n    }\n  })(database);\n}\n"]}

package/lib/index.cjs

@@ -0,0 +1,34 @@
+"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.VERSION = void 0;
+__exportStar(require("./adapter.cjs"), exports);
+__exportStar(require("./PouchRepository.cjs"), exports);
+__exportStar(require("./utils.cjs"), exports);
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module for-nano
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:ts-workspace
+ */
+exports.VERSION = "0.0.1";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQixvREFBa0M7QUFDbEMsMENBQXdCO0FBRXhCOzs7O0dBSUc7QUFFSDs7Ozs7R0FLRztBQUNVLFFBQUEsT0FBTyxHQUFHLE9BQU8sQ0FBQyIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2FkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1BvdWNoUmVwb3NpdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBNb2R1bGUgc3VtbWFyeVxuICogQGRlc2NyaXB0aW9uIE1vZHVsZSBkZXNjcmlwdGlvblxuICogQG1vZHVsZSBmb3ItbmFub1xuICovXG5cbi8qKlxuICogQHN1bW1hcnkgc3RvcmVzIHRoZSBjdXJyZW50IHBhY2thZ2UgdmVyc2lvblxuICogQGRlc2NyaXB0aW9uIHRoaXMgaXMgaG93IHlvdSBzaG91bGQgZG9jdW1lbnQgYSBjb25zdGFudFxuICogQGNvbnN0IFZFUlNJT05cbiAqIEBtZW1iZXJPZiBtb2R1bGU6dHMtd29ya3NwYWNlXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIwLjAuMVwiO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./adapter";
+export * from "./PouchRepository";
+export * from "./utils";
+/**
+ * @summary Module summary
+ * @description Module description
+ * @module for-nano
+ */
+/**
+ * @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/utils.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toServerScope = toServerScope;
+exports.toDocumentScope = toDocumentScope;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+function toServerScope(pouch) {
+    return new (class {
+        constructor(pouch) {
+            this.pouch = pouch;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        use(db) {
+            throw new Error("Method not implemented.");
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        auth(username, userpass) {
+            throw new Error("Method not implemented.");
+        }
+        session() {
+            throw new Error("Method not implemented.");
+        }
+    })(pouch);
+}
+function toDocumentScope(database) {
+    return new (class {
+        constructor(db) {
+            this.db = db;
+        }
+        async fetch(docnames) {
+            const result = await this.db.bulkGet({
+                docs: docnames.keys.map((k) => ({ id: k })),
+            });
+            return {
+                offset: 0,
+                rows: result.results.reduce((accum, r) => {
+                    const docs = r.docs.map((d) => {
+                        if (d["error"])
+                            throw new db_decorators_1.InternalError(d["error"]);
+                        return d["ok"];
+                    });
+                    accum.push(...docs);
+                    return accum;
+                }, []),
+                total_rows: 0,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        auth(username, userpass) {
+            throw new Error("Method not implemented.");
+        }
+        session() {
+            throw new Error("Method not implemented.");
+        }
+        async insert(document) {
+            return this.db.put(document);
+        }
+        get(docname, params) {
+            return new Promise((resolve, reject) => {
+                this.db.get(docname, params || {}, (err, result) => {
+                    if (err)
+                        return reject(err);
+                    resolve(result);
+                });
+            });
+        }
+        destroy(docname, rev) {
+            return this.db.remove({ _id: docname, _rev: rev });
+        }
+        async bulk(docs) {
+            const results = await this.db.bulkDocs(docs.docs);
+            return results.map((r) => {
+                if (r instanceof Error)
+                    return { ok: false };
+                return Object.assign({
+                    ok: true,
+                }, r);
+            });
+        }
+        async createIndex(indexDef) {
+            const result = await this.db.createIndex(indexDef);
+            return {
+                result: result.result,
+                id: indexDef.ddoc,
+                name: indexDef.name,
+            };
+        }
+        find(query) {
+            return this.db.find(query);
+        }
+        get server() {
+            return this.db;
+        }
+    })(database);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/utils.ts"],"names":[],"mappings":"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","file":"utils.js","sourcesContent":["import Database = PouchDB.Database;\nimport {\n  BulkFetchDocsWrapper,\n  BulkModifyDocsWrapper,\n  CreateIndexRequest,\n  CreateIndexResponse,\n  DatabaseAuthResponse,\n  DatabaseSessionResponse,\n  DocumentDestroyResponse,\n  DocumentGetParams,\n  DocumentInsertResponse,\n  DocumentScope,\n  MangoQuery,\n  MangoResponse,\n  ServerScope,\n  DocumentFetchResponse,\n} from \"@decaf-ts/for-couchdb\";\nimport FindRequest = PouchDB.Find.FindRequest;\nimport BulkGetResponse = PouchDB.Core.BulkGetResponse;\nimport { InternalError } from \"@decaf-ts/db-decorators\";\n\nexport function toServerScope(pouch: typeof PouchDB) {\n  return new (class implements ServerScope {\n    constructor(public pouch: typeof PouchDB) {}\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    use<D>(db: string): DocumentScope<D> {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    auth(username: string, userpass: string): Promise<DatabaseAuthResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    session(): Promise<DatabaseSessionResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n  })(pouch);\n}\n\nexport function toDocumentScope(database: Database) {\n  return new (class implements DocumentScope<any> {\n    constructor(public db: Database) {}\n\n    async fetch(\n      docnames: BulkFetchDocsWrapper\n    ): Promise<DocumentFetchResponse<any>> {\n      const result: BulkGetResponse<any> = await this.db.bulkGet({\n        docs: docnames.keys.map((k: string) => ({ id: k })),\n      });\n      return {\n        offset: 0,\n        rows: result.results.reduce((accum: any[], r) => {\n          const docs: any[] = r.docs.map((d) => {\n            if ((d as any)[\"error\"])\n              throw new InternalError((d as any)[\"error\"]);\n            return (d as any)[\"ok\"] as any;\n          });\n          accum.push(...docs);\n          return accum;\n        }, []),\n        total_rows: 0,\n      };\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    auth(username: string, userpass: string): Promise<DatabaseAuthResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n    session(): Promise<DatabaseSessionResponse> {\n      throw new Error(\"Method not implemented.\");\n    }\n    async insert(document: any): Promise<DocumentInsertResponse> {\n      return this.db.put(document);\n    }\n    get(docname: string, params?: DocumentGetParams | undefined): Promise<any> {\n      return new Promise<any>((resolve, reject) => {\n        this.db.get(docname, params || {}, (err, result) => {\n          if (err) return reject(err);\n          resolve(result);\n        });\n      });\n    }\n    destroy(docname: string, rev: string): Promise<DocumentDestroyResponse> {\n      return this.db.remove({ _id: docname, _rev: rev });\n    }\n    async bulk(docs: BulkModifyDocsWrapper): Promise<DocumentInsertResponse[]> {\n      const results = await this.db.bulkDocs(docs.docs);\n      return results.map((r) => {\n        if (r instanceof Error) return { ok: false };\n        return Object.assign(\n          {\n            ok: true,\n          },\n          r\n        );\n      }) as DocumentInsertResponse[];\n    }\n    async createIndex(\n      indexDef: CreateIndexRequest\n    ): Promise<CreateIndexResponse> {\n      const result = await this.db.createIndex(indexDef as any);\n      return {\n        result: result.result,\n        id: indexDef.ddoc as string,\n        name: indexDef.name as string,\n      };\n    }\n    find(query: MangoQuery): Promise<MangoResponse<any>> {\n      return this.db.find(query as unknown as FindRequest<any>);\n    }\n    get server() {\n      return this.db as unknown as ServerScope;\n    }\n  })(database);\n}\n"]}

package/lib/utils.d.ts

@@ -0,0 +1,21 @@
+import Database = PouchDB.Database;
+import { BulkFetchDocsWrapper, BulkModifyDocsWrapper, CreateIndexRequest, CreateIndexResponse, DatabaseAuthResponse, DatabaseSessionResponse, DocumentDestroyResponse, DocumentGetParams, DocumentInsertResponse, DocumentScope, MangoQuery, MangoResponse, ServerScope, DocumentFetchResponse } from "@decaf-ts/for-couchdb";
+export declare function toServerScope(pouch: typeof PouchDB): {
+    pouch: typeof PouchDB;
+    use<D>(db: string): DocumentScope<D>;
+    auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;
+    session(): Promise<DatabaseSessionResponse>;
+};
+export declare function toDocumentScope(database: Database): {
+    db: Database;
+    fetch(docnames: BulkFetchDocsWrapper): Promise<DocumentFetchResponse<any>>;
+    auth(username: string, userpass: string): Promise<DatabaseAuthResponse>;
+    session(): Promise<DatabaseSessionResponse>;
+    insert(document: any): Promise<DocumentInsertResponse>;
+    get(docname: string, params?: DocumentGetParams | undefined): Promise<any>;
+    destroy(docname: string, rev: string): Promise<DocumentDestroyResponse>;
+    bulk(docs: BulkModifyDocsWrapper): Promise<DocumentInsertResponse[]>;
+    createIndex(indexDef: CreateIndexRequest): Promise<CreateIndexResponse>;
+    find(query: MangoQuery): Promise<MangoResponse<any>>;
+    readonly server: ServerScope;
+};