cozy-pouch-link 57.5.0 → 57.6.1

package/dist/utils.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.allSettled = exports.formatAggregatedError = exports.getPrefix = exports.getDatabaseName = void 0;
-
+exports.allSettled = exports.formatAggregatedError = exports.getPrefix = exports.getDoctypeFromDatabaseName = exports.getOldDatabaseName = exports.getDatabaseName = exports.DATABASE_NAME_SEPARATOR = void 0;
+var DATABASE_NAME_SEPARATOR = '__doctype__';
 /**
  * Get the database name based on prefix and doctype
  *
@@ -13,9 +13,39 @@ exports.allSettled = exports.formatAggregatedError = exports.getPrefix = exports
  *
  * @returns {string} The database name
  */
+
+exports.DATABASE_NAME_SEPARATOR = DATABASE_NAME_SEPARATOR;
+
 var getDatabaseName = function getDatabaseName(prefix, doctype) {
+  return "".concat(prefix).concat(DATABASE_NAME_SEPARATOR).concat(doctype);
+};
+/**
+ * Get the old database name, based on prefix and doctype
+ * Used for migration purposes
+ *
+ * @param {string} prefix - The URL prefix
+ * @param {string} doctype - The database doctype
+ *
+ * @returns {string} The database name
+ */
+
+
+exports.getDatabaseName = getDatabaseName;
+
+var getOldDatabaseName = function getOldDatabaseName(prefix, doctype) {
   return "".concat(prefix, "_").concat(doctype);
 };
+
+exports.getOldDatabaseName = getOldDatabaseName;
+
+var getDoctypeFromDatabaseName = function getDoctypeFromDatabaseName(dbName) {
+  if (!dbName) {
+    return null;
+  }
+
+  var tokens = dbName.split(DATABASE_NAME_SEPARATOR);
+  return tokens[tokens.length - 1];
+};
 /**
  * Get the URI prefix
  *
@@ -24,7 +54,7 @@ var getDatabaseName = function getDatabaseName(prefix, doctype) {
  */
 
 
-exports.getDatabaseName = getDatabaseName;
+exports.getDoctypeFromDatabaseName = getDoctypeFromDatabaseName;
 
 var getPrefix = function getPrefix(uri) {
   return uri.replace(/^https?:\/\//, '');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-pouch-link",
-  "version": "57.5.0",
+  "version": "57.6.1",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -13,13 +13,14 @@
     "url": "git+https://github.com/cozy/cozy-client.git"
   },
   "dependencies": {
-    "cozy-client": "^57.5.0",
+    "cozy-client": "^57.6.0",
     "pouchdb-browser": "^7.2.2",
     "pouchdb-find": "^7.2.2"
   },
   "devDependencies": {
     "@babel/cli": "7.12.8",
     "@cozy/minilog": "1.0.0",
+    "@op-engineering/op-sqlite": "^11.4.8",
     "cozy-device-helper": "2.7.0",
     "jest-localstorage-mock": "2.4.19",
     "parcel": "2.13.3",
@@ -30,6 +31,7 @@
   },
   "peerDependencies": {
     "@cozy/minilog": "1.0.0",
+    "@op-engineering/op-sqlite": "*",
     "cozy-device-helper": ">=2.1.0"
   },
   "scripts": {
@@ -39,5 +41,5 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "sideEffects": false,
-  "gitHead": "1244b5d668b419f7c10e7474160211b3ec6bbe41"
+  "gitHead": "c8b0e04cccbdb92b0a846a7d25ac1c8f990fe3ce"
 }

package/types/CozyPouchLink.d.ts

@@ -1,6 +1,6 @@
 export function getReplicationURL(uri: any, token: any, doctype: any): string;
 export default PouchLink;
-export type CozyClientDocument = any;
+export type CozyPouchDocument = any;
 export type ReplicationStatus = "idle" | "replicating";
 export type PouchLinkOptions = {
     /**
@@ -41,8 +41,7 @@ export type PouchLinkOptions = {
     performanceApi?: any;
 };
 /**
- * @typedef {import('cozy-client/src/types').CozyClientDocument} CozyClientDocument
- *
+ * @typedef {import('cozy-client/src/types').CozyClientDocument & { cozyPouchData: any }} CozyPouchDocument *
  * @typedef {"idle"|"replicating"} ReplicationStatus
  */
 /**
@@ -125,6 +124,7 @@ declare class PouchLink extends CozyLink {
         plugins?: Array<object>;
     }): Promise<void>;
     onLogin(): Promise<void>;
+    queryEngine: import("./db/dbInterface").default | typeof PouchDBQueryEngine;
     pouches: PouchManager;
     /**
      * Receives PouchDB updates (documents grouped by doctype).
@@ -180,6 +180,7 @@ declare class PouchLink extends CozyLink {
     public stopReplication(): void;
     onSyncError(error: any): Promise<void>;
     getSyncInfo(doctype: any): import("./types").SyncInfo;
+    getQueryEngineFromDoctype(doctype: any): any;
     getPouch(doctype: any): any;
     supportsOperation(operation: any): boolean;
     /**
@@ -199,17 +200,6 @@ declare class PouchLink extends CozyLink {
      * @returns {Promise<import('./types').PouchDBInfo>} The db info
      */
     getDbInfo(doctype: string): Promise<import('./types').PouchDBInfo>;
-    sanitizeJsonApi(data: any): Pick<Pick<any, string | number | symbol>, string | number | symbol>;
-    /**
-     * Retrieve the existing document from Pouch
-     *
-     * @private
-     * @param {*} id - ID of the document to retrieve
-     * @param {*} type - Doctype of the document to retrieve
-     * @param {*} throwIfNotFound - If true the method will throw when the document is not found. Otherwise it will return null
-     * @returns {Promise<CozyClientDocument | null>}
-     */
-    private getExistingDocument;
     /**
      *
      * Check if there is warmup queries for this doctype
@@ -220,45 +210,6 @@ declare class PouchLink extends CozyLink {
      */
     needsToWaitWarmup(doctype: string): Promise<boolean>;
     hasIndex(name: any): boolean;
-    /**
-     * Create the PouchDB index if not existing
-     *
-     * @param {Array} fields - Fields to index
-     * @param {object} indexOption - Options for the index
-     * @param {object} [indexOption.partialFilter] - partialFilter
-     * @param {string} [indexOption.indexName] - indexName
-     * @param {string} [indexOption.doctype] - doctype
-     * @returns {Promise<import('./types').PouchDbIndex>}
-     */
-    createIndex(fields: any[], { partialFilter, indexName, doctype }?: {
-        partialFilter: object;
-        indexName: string;
-        doctype: string;
-    }): Promise<import('./types').PouchDbIndex>;
-    /**
-     * Retrieve the PouchDB index if exist, undefined otherwise
-     *
-     * @param {string} doctype - The query's doctype
-     * @param {import('./types').MangoQueryOptions} options - The find options
-     * @param {string} indexName - The index name
-     * @returns {import('./types').PouchDbIndex | undefined}
-     */
-    findExistingIndex(doctype: string, options: import('./types').MangoQueryOptions, indexName: string): import('./types').PouchDbIndex | undefined;
-    /**
-     * Handle index creation if it is missing.
-     *
-     * When an index is missing, we first check if there is one with a different
-     * name but the same definition. If there is none, we create the new index.
-     *
-     * /!\ Warning: this method is similar to DocumentCollection.handleMissingIndex()
-     * If you edit this method, please check if the change is also needed in DocumentCollection
-     *
-     * @param {string} doctype The mango selector
-     * @param {import('./types').MangoQueryOptions} options The find options
-     * @returns {Promise<import('./types').PouchDbIndex>} index
-     * @private
-     */
-    private ensureIndex;
     executeQuery({ doctype, selector, sort, fields, limit, id, ids, skip, indexedFields, partialFilter }: {
         doctype: any;
         selector: any;
@@ -270,16 +221,7 @@ declare class PouchLink extends CozyLink {
         skip: any;
         indexedFields: any;
         partialFilter: any;
-    }): Promise<{
-        data: any;
-        meta: {
-            count: any;
-        };
-        skip: any;
-        next: boolean;
-    } | {
-        data: any;
-    }>;
+    }): Promise<any>;
     executeMutation(mutation: any, options: any, result: any, forward: any): Promise<any>;
     createDocument(mutation: any): Promise<any>;
     updateDocument(mutation: any): Promise<any>;
@@ -291,4 +233,5 @@ declare class PouchLink extends CozyLink {
 }
 import { CozyLink } from "cozy-client";
 import { PouchLocalStorage } from "./localStorage";
+import PouchDBQueryEngine from "./db/pouchdb/pouchdb";
 import PouchManager from "./PouchManager";

package/types/PouchManager.d.ts

@@ -10,9 +10,12 @@ declare class PouchManager {
     options: any;
     doctypes: any;
     storage: PouchLocalStorage;
+    queryEngine: any;
+    client: any;
     PouchDB: any;
     isOnline: any;
     events: any;
+    dbQueryEngines: Map<any, any>;
     init(): Promise<void>;
     pouches: import("lodash").Dictionary<any>;
     /** @type {Record<string, import('./types').SyncInfo>} - Stores synchronization info per doctype */
@@ -62,7 +65,9 @@ declare class PouchManager {
     handleReplicationError(err: any): void;
     cancelCurrentReplications(): void;
     waitForCurrentReplications(): Promise<void> | Promise<(import("./utils").FulfilledPromise | import("./utils").RejectedPromise)[]>;
-    getPouch(doctype: any): any;
+    getPouch(dbName: any): any;
+    setQueryEngine(name: any, doctype: any): any;
+    getQueryEngine(name: any, doctype: any): any;
     /**
      * Update the Sync info for the specifed doctype
      *

package/types/__mocks__/@op-engineering/op-sqlite.d.ts

@@ -0,0 +1 @@
+export function open(): void;

package/types/db/dbInterface.d.ts

@@ -0,0 +1,117 @@
+export default DatabaseQueryEngine;
+export type FindParams = {
+    /**
+     * - The mango selector
+     */
+    selector: object;
+    /**
+     * - Following the mango selector syntax, used to filter out documents at indexing time
+     */
+    partialFilter: object;
+    /**
+     * - The mango sort
+     */
+    sort: any[];
+    /**
+     * - The doctype
+     */
+    doctype: string;
+    /**
+     * - Array of indexed field name
+     */
+    indexedFields: Array<string>;
+    /**
+     * - Maximum number of documents to return
+     */
+    limit: number;
+    /**
+     * - Number of documents to skip
+     */
+    skip: number;
+    /**
+     * - Whether or not an existing index should be recreated
+     */
+    recreateIndex: boolean;
+};
+export type AllDocsParams = {
+    /**
+     * - Maximum number of documents to return
+     */
+    limit: number;
+    /**
+     * - Number of documents to skip
+     */
+    skip: number;
+};
+export type QueryResponse = {
+    /**
+     * - The documents retrieved by the query
+     */
+    data: Array<object>;
+};
+export type QueryResponseSingleDoc = {
+    /**
+     * - The document retrieved by the query
+     */
+    data: object;
+};
+/**
+ * @typedef {object} FindParams
+ * @property {object} selector - The mango selector
+ * @property {object} partialFilter - Following the mango selector syntax, used to filter out documents at indexing time
+ * @property {Array} sort - The mango sort
+ * @property {string} doctype - The doctype
+ * @property {Array<string>} indexedFields - Array of indexed field name
+ * @property {number} limit - Maximum number of documents to return
+ * @property {number} skip - Number of documents to skip
+ * @property {boolean} recreateIndex - Whether or not an existing index should be recreated
+ */
+/**
+ * @typedef {object} AllDocsParams
+ * @property {number} limit - Maximum number of documents to return
+ * @property {number} skip - Number of documents to skip
+ */
+/**
+ * @typedef {object} QueryResponse
+ * @property {Array<object>} data - The documents retrieved by the query
+ */
+/**
+ * @typedef {object} QueryResponseSingleDoc
+ * @property {object} data - The document retrieved by the query
+ */
+declare class DatabaseQueryEngine {
+    /**
+     * Open the database
+     *
+     * @param {string} dbName - The database name
+     */
+    openDB(dbName: string): void;
+    /**
+     * Find docs with filtered query
+     *
+     * @param {FindParams} options - The find options
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+    find(options: FindParams): Promise<QueryResponse>;
+    /**
+     * Get all docs
+     *
+     * @param {AllDocsParams} options - The all docs options
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+    allDocs(options: AllDocsParams): Promise<QueryResponse>;
+    /**
+     * Get a single doc by its id
+     *
+     * @param {string} id - id of the document to get
+     * @returns {Promise<QueryResponseSingleDoc>} The found docs
+     */
+    getById(id: string): Promise<QueryResponseSingleDoc>;
+    /**
+     * Get several docs by their ids
+     *
+     * @param {Array<string>} ids - ids of the documents to get
+     * @returns {Promise<QueryResponse>} The found docs
+     */
+    getByIds(ids: Array<string>): Promise<QueryResponse>;
+}

package/types/db/helpers.d.ts

@@ -0,0 +1,4 @@
+export function getExistingDocument(queryEngine: DatabaseQueryEngine, id: string, throwIfNotFound?: boolean): Promise<import('./dbInterface').QueryResponseSingleDoc>;
+export function areDocsEqual(oldDoc: any, newDoc: any): Promise<boolean>;
+export function getCozyPouchData(doc: import('../CozyPouchLink').CozyPouchDocument): Array<import('cozy-client/types/types').CozyClientDocument>;
+import DatabaseQueryEngine from "./dbInterface";

package/types/db/pouchdb/getDocs.d.ts

@@ -0,0 +1,18 @@
+export function getDocsAndNormalize({ client, doctype, db, queryFunc, queryParams, withRows }: {
+    client: any;
+    doctype: any;
+    db: any;
+    queryFunc: any;
+    queryParams?: {};
+    withRows?: boolean;
+}): Promise<{
+    data: any;
+    meta: {
+        count: any;
+    };
+    skip: any;
+    next: boolean;
+} | {
+    data: any;
+}>;
+export function getDocs(db: any, fct: any, queryParams?: {}): any;

package/types/db/pouchdb/pouchdb.d.ts

@@ -0,0 +1,8 @@
+export default class PouchDBQueryEngine extends DatabaseQueryEngine {
+    constructor(pouchManager: any, doctype: any);
+    pouchManager: any;
+    client: any;
+    doctype: any;
+    db: any;
+}
+import DatabaseQueryEngine from "../dbInterface";

package/types/db/sqlite/sql.d.ts

@@ -0,0 +1,45 @@
+export function keepDocWitHighestRev(docs: any): any;
+export function parseResults(client: any, result: any, doctype: any, { isSingleDoc, skip, limit }?: {
+    isSingleDoc?: boolean;
+    skip?: number;
+    limit?: number;
+}): {
+    data: any;
+    meta?: undefined;
+    skip?: undefined;
+    next?: undefined;
+} | {
+    data: any[];
+    meta: {
+        count: number;
+    };
+    skip: number;
+    next: boolean;
+};
+export function mangoSelectorToSQL(selector: any): string;
+export function makeWhereClause(selector: any): string;
+export function makeSortClause(mangoSortBy: any): string;
+export function makeSQLQueryFromMango({ selector, sort, indexName, limit, skip }: {
+    selector: any;
+    sort: any;
+    indexName: any;
+    limit?: number;
+    skip?: number;
+}): string;
+export function makeSQLQueryForId(id: any): string;
+export function makeSQLQueryForIds(ids: any): string;
+export function makeSQLQueryAll({ limit, skip }?: {
+    limit?: number;
+    skip?: number;
+}): string;
+export function makeSQLDropIndex(indexName: any): string;
+export function makeSQLCreateMangoIndex(indexName: any, fieldsToIndex: any, { partialFilter }: {
+    partialFilter: any;
+}): string;
+export function makeSQLCreateDocIDIndex(): string;
+export function makeSQLCreateDeletedIndex(): string;
+export function createMangoIndex(db: any, indexName: any, fieldsToIndex: any, { partialFilter }: {
+    partialFilter: any;
+}): Promise<any>;
+export function deleteIndex(db: any, indexName: any): Promise<void>;
+export function executeSQL(db: any, sql: any): Promise<any>;

package/types/db/sqlite/sqliteDb.d.ts

@@ -0,0 +1,4 @@
+export default class SQLiteQueryEngine extends DatabaseQueryEngine {
+    constructor(pouchManager: any, doctype: any);
+}
+import DatabaseQueryEngine from "../dbInterface";

package/types/db/sqlite/sqliteDb.native.d.ts

@@ -0,0 +1,7 @@
+export default class SQLiteQueryEngine extends DatabaseQueryEngine {
+    constructor(pouchManager: any, doctype: any);
+    db: import("@op-engineering/op-sqlite").DB;
+    client: any;
+    doctype: any;
+}
+import DatabaseQueryEngine from "../dbInterface";

package/types/errors.d.ts

@@ -1 +1,3 @@
 export function isExpiredTokenError(error: any): any;
+export function isMissingSQLiteIndexError(error: any): boolean;
+export function isMissingPouchDBIndexError(error: any): boolean;

package/types/helpers.d.ts

@@ -1,10 +1,7 @@
+export const LIMIT_BUG: 999;
 export default helpers;
 declare namespace helpers {
     function isAdapterBugged(adapterName: any): boolean;
-    function withoutDesignDocuments(res: any): any;
-    function getDocs(db: any, fct: any, options?: {}): any;
-    function allDocs(db: any, options?: {}): Promise<any>;
-    function find(db: any, options?: {}): Promise<any>;
     function isDesignDocument(doc: any): boolean;
     function isDeletedDocument(doc: any): any;
     function insertBulkDocs(db: any, docs: any): Promise<any>;

package/types/index.d.ts

@@ -1 +1,2 @@
 export { default } from "./CozyPouchLink";
+export { default as SQLiteQuery } from "./db/sqlite/sqliteDb";

package/types/jsonapi.d.ts

@@ -1,5 +1,5 @@
-export function normalizeDocs(client: CozyClient, doctype: string, docs: Array<import('./CozyPouchLink').CozyClientDocument>): void;
-export function normalizeDoc(client: CozyClient, doctype: string, doc: any): void;
+export function normalizeDocs(client: CozyClient, doctype: string, docs: Array<import('./CozyPouchLink').CozyPouchDocument>): void;
+export function normalizeDoc(client: CozyClient, doctype: string, doc: import('./CozyPouchLink').CozyPouchDocument): void;
 export function fromPouchResult({ res, withRows, doctype, client }: {
     res: any;
     withRows: any;
@@ -15,4 +15,6 @@ export function fromPouchResult({ res, withRows, doctype, client }: {
 } | {
     data: any;
 };
+export function sanitized(doc: any): Pick<any, string | number | symbol>;
+export function sanitizeJsonApi(doc: any): Pick<Pick<any, string | number | symbol>, string | number | symbol>;
 import CozyClient from "cozy-client";

package/types/mango.d.ts

@@ -1,3 +1,21 @@
 export function makeKeyFromPartialFilter(condition: object): string;
 export function getIndexNameFromFields(fields: Array<string>, partialFilter?: object): string;
-export function getIndexFields({ selector, sort, partialFilter }: import('./types').MangoQueryOptions): string[];
+export function getIndexFieldsFromFind({ selector, sort, partialFilter }: import('./types').MangoQueryOptions): string[];
+export function createIndex(db: object, fields: any[], { partialFilter, indexName, doctype }?: {
+    partialFilter: object;
+    indexName: string;
+    doctype: string;
+}): Promise<import('./types').PouchDbIndex>;
+export function findExistingIndex(doctype: string, options: import('./types').MangoQueryOptions, indexName: string): import('./types').PouchDbIndex | undefined;
+export function getIndexFields({ selector, sort, partialFilter, indexedFields }: {
+    selector: any;
+    sort: any;
+    partialFilter: any;
+    indexedFields: any;
+}): any;
+export function getIndexName({ selector, sort, indexedFields, partialFilter }: {
+    selector: any;
+    sort: any;
+    indexedFields: any;
+    partialFilter: any;
+}): string;

package/types/migrations/pouchdb.d.ts

@@ -0,0 +1 @@
+export function destroyOldDatabases(PouchDB: any, doctypes: any, prefix: any): void;

package/types/types.d.ts

@@ -33,6 +33,7 @@ export type LinkPlatform = {
      * PouchDB class (can be pouchdb-core or pouchdb-browser)
      */
     pouchAdapter: any;
+    queryEngine: DatabaseQueryEngine;
     /**
      * Method that check if the app is connected to internet
      */
@@ -144,3 +145,4 @@ export type PouchDBChanges = {
      */
     doc: object;
 };
+import DatabaseQueryEngine from "./db/dbInterface";

package/types/utils.d.ts

@@ -1,4 +1,7 @@
+export const DATABASE_NAME_SEPARATOR: "__doctype__";
 export function getDatabaseName(prefix: string, doctype: string): string;
+export function getOldDatabaseName(prefix: string, doctype: string): string;
+export function getDoctypeFromDatabaseName(dbName: any): any;
 export function getPrefix(uri: string): string;
 export function formatAggregatedError(aggregatedError: any): any;
 export function allSettled(promises: Promise<any>[]): Promise<(FulfilledPromise | RejectedPromise)[]>;