@decaf-ts/for-couchdb
Version:
template for ts projects
176 lines • 21.7 kB
JavaScript
import { PersistenceKeys } from "@decaf-ts/core";
import { CouchDBKeys } from "./constants.js";
import { DefaultSeparator } from "@decaf-ts/db-decorators";
import { CouchDBOperator } from "./query/constants.js";
/**
* @description Re-authenticates a connection to CouchDB
* @summary Refreshes the authentication for a CouchDB connection using the provided credentials
* @param {any} con - The CouchDB connection object
* @param {string} user - The username for authentication
* @param {string} pass - The password for authentication
* @return {Promise<any>} A promise that resolves to the authentication result
* @function reAuth
* @memberOf module:for-couchdb
*/
export async function reAuth(con, user, pass) {
return con.auth(user, pass);
}
/**
* @description Wraps a CouchDB database connection with automatic re-authentication
* @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation
* @param {any} con - The CouchDB connection object
* @param {string} dbName - The name of the database to use
* @param {string} user - The username for authentication
* @param {string} pass - The password for authentication
* @return {any} The wrapped database connection object
* @function wrapDocumentScope
* @memberOf module:for-couchdb
* @mermaid
* sequenceDiagram
* participant Client
* participant wrapDocumentScope
* participant DB
* participant reAuth
*
* Client->>wrapDocumentScope: con, dbName, user, pass
* wrapDocumentScope->>DB: con.use(dbName)
* Note over wrapDocumentScope: Wrap DB methods with re-auth
*
* loop For each method (insert, get, put, destroy, find)
* wrapDocumentScope->>wrapDocumentScope: Store original method
* wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth
* end
*
* wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value
* wrapDocumentScope-->>Client: Return wrapped DB
*
* Note over Client: Later when client uses DB methods
* Client->>DB: Any wrapped method call
* DB->>reAuth: Authenticate before operation
* reAuth-->>DB: Authentication complete
* DB->>DB: Call original method
* DB-->>Client: Return result
*/
export function wrapDocumentScope(con, dbName, user, pass) {
const db = con.use(dbName);
["insert", "get", "put", "destroy", "find"].forEach((k) => {
const original = db[k];
Object.defineProperty(db, k, {
enumerable: false,
configurable: true,
value: async (...args) => {
await reAuth(con, user, pass);
return original.call(db, ...args);
},
});
});
Object.defineProperty(db, CouchDBKeys.NATIVE, {
enumerable: false,
configurable: false,
writable: false,
value: con,
});
return db;
}
/**
* @description Tests if an attribute name is reserved in CouchDB
* @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB
* @param {string} attr - The attribute name to test
* @return {RegExpMatchArray|null} The match result or null if no match
* @function testReservedAttributes
* @memberOf module:for-couchdb
*/
export function testReservedAttributes(attr) {
const regexp = /^_.*$/g;
return attr.match(regexp);
}
/**
* @description Generates a name for a CouchDB index
* @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order
* @param {string} attribute - The primary attribute for the index
* @param {string} tableName - The name of the table
* @param {string[]} [compositions] - Optional additional attributes to include in the index
* @param {OrderDirection} [order] - Optional sort order for the index
* @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
* @return {string} The generated index name
* @function generateIndexName
* @memberOf module:for-couchdb
*/
export function generateIndexName(attribute, tableName, compositions, order, separator = DefaultSeparator) {
const attr = [PersistenceKeys.INDEX, tableName, attribute];
if (compositions)
attr.push(...compositions);
if (order)
attr.push(order);
return attr.join(separator);
}
/**
* @description Generates a CouchDB index configuration
* @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters
* @param {string} attribute - The primary attribute for the index
* @param {string} tableName - The name of the table
* @param {string[]} [compositions] - Optional additional attributes to include in the index
* @param {OrderDirection} [order] - Optional sort order for the index
* @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
* @return {CreateIndexRequest} The complete index configuration object
* @function generateIndexDoc
* @memberOf module:for-couchdb
* @mermaid
* sequenceDiagram
* participant Caller
* participant generateIndexDoc
* participant generateIndexName
*
* Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator
*
* Note over generateIndexDoc: Create partial filter selector
* generateIndexDoc->>generateIndexDoc: Set up filter for tableName
*
* alt order is specified
* Note over generateIndexDoc: Create ordered fields array
* generateIndexDoc->>generateIndexDoc: Create orderProp for attribute
* generateIndexDoc->>generateIndexDoc: Map compositions to ordered props
* generateIndexDoc->>generateIndexDoc: Create sortedTable for table field
* generateIndexDoc->>generateIndexDoc: Combine all ordered fields
* else
* Note over generateIndexDoc: Create simple fields array
* generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings
* end
*
* generateIndexDoc->>generateIndexName: Generate index name
* generateIndexName-->>generateIndexDoc: Return name
*
* Note over generateIndexDoc: Create final index request
* generateIndexDoc-->>Caller: Return CreateIndexRequest
*/
export function generateIndexDoc(attribute, tableName, compositions, order, separator = DefaultSeparator) {
const partialFilterSelector = {};
partialFilterSelector[CouchDBKeys.TABLE] = {};
partialFilterSelector[CouchDBKeys.TABLE][CouchDBOperator.EQUAL] = tableName;
let fields;
if (order) {
const orderProp = {};
orderProp[attribute] = order;
const sortedCompositions = (compositions || []).map((c) => {
const r = {};
r[c] = order;
return r;
});
const sortedTable = {};
sortedTable[CouchDBKeys.TABLE] = order;
fields = [orderProp, ...sortedCompositions, sortedTable];
}
else {
fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];
}
const name = generateIndexName(attribute, tableName, compositions, order, separator);
return {
index: {
fields: fields,
// partial_filter_selector: partialFilterSelector,
},
ddoc: [name, CouchDBKeys.DDOC].join(separator),
name: name,
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,uBAAoB;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,6BAA0B;AAGpD;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,GAAQ,EAAE,IAAY,EAAE,IAAY;IAC/D,OAAO,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAQ,EACR,MAAc,EACd,IAAY,EACZ,IAAY;IAEZ,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;QACxD,MAAM,QAAQ,GAAI,EAA0B,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,EAAE;YAC3B,UAAU,EAAE,KAAK;YACjB,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK,EAAE,GAAG,IAAW,EAAE,EAAE;gBAC9B,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC9B,OAAO,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;YACpC,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,WAAW,CAAC,MAAM,EAAE;QAC5C,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,KAAK;QACnB,QAAQ,EAAE,KAAK;QACf,KAAK,EAAE,GAAG;KACX,CAAC,CAAC;IACH,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAY;IACjD,MAAM,MAAM,GAAG,QAAQ,CAAC;IACxB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAAiB,EACjB,SAAiB,EACjB,YAAuB,EACvB,KAAsB,EACtB,SAAS,GAAG,gBAAgB;IAE5B,MAAM,IAAI,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IAC3D,IAAI,YAAY;QAAE,IAAI,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;IAC7C,IAAI,KAAK;QAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,SAAiB,EACjB,YAAuB,EACvB,KAAsB,EACtB,SAAS,GAAG,gBAAgB;IAE5B,MAAM,qBAAqB,GAAkB,EAAE,CAAC;IAChD,qBAAqB,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,EAAmB,CAAC;IAC9D,qBAAqB,CAAC,WAAW,CAAC,KAAK,CAAmB,CACzD,eAAe,CAAC,KAAK,CACtB,GAAG,SAAS,CAAC;IACd,IAAI,MAAmB,CAAC;IACxB,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,SAAS,GAAc,EAAE,CAAC;QAChC,SAAS,CAAC,SAAS,CAAC,GAAG,KAAuB,CAAC;QAC/C,MAAM,kBAAkB,GAAgB,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACrE,MAAM,CAAC,GAAc,EAAE,CAAC;YACxB,CAAC,CAAC,CAAC,CAAC,GAAG,KAAuB,CAAC;YAC/B,OAAO,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QACH,MAAM,WAAW,GAAc,EAAE,CAAC;QAClC,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,KAAuB,CAAC;QACzD,MAAM,GAAG,CAAC,SAAS,EAAE,GAAG,kBAAkB,EAAE,WAAW,CAAC,CAAC;IAC3D,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,IAAI,GAAG,iBAAiB,CAC5B,SAAS,EACT,SAAS,EACT,YAAY,EACZ,KAAK,EACL,SAAS,CACV,CAAC;IACF,OAAO;QACL,KAAK,EAAE;YACL,MAAM,EAAE,MAAM;YACd,kDAAkD;SACnD;QACD,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QAC9C,IAAI,EAAE,IAAI;KACX,CAAC;AACJ,CAAC","sourcesContent":["import { OrderDirection, PersistenceKeys } from \"@decaf-ts/core\";\nimport { CouchDBKeys } from \"./constants\";\nimport { DefaultSeparator } from \"@decaf-ts/db-decorators\";\nimport { CouchDBOperator } from \"./query/constants\";\nimport { CreateIndexRequest, MangoSelector, SortOrder } from \"./types\";\n\n/**\n * @description Re-authenticates a connection to CouchDB\n * @summary Refreshes the authentication for a CouchDB connection using the provided credentials\n * @param {any} con - The CouchDB connection object\n * @param {string} user - The username for authentication\n * @param {string} pass - The password for authentication\n * @return {Promise<any>} A promise that resolves to the authentication result\n * @function reAuth\n * @memberOf module:for-couchdb\n */\nexport async function reAuth(con: any, user: string, pass: string) {\n  return con.auth(user, pass);\n}\n\n/**\n * @description Wraps a CouchDB database connection with automatic re-authentication\n * @summary Creates a proxy around a CouchDB database connection that automatically re-authenticates before each operation\n * @param {any} con - The CouchDB connection object\n * @param {string} dbName - The name of the database to use\n * @param {string} user - The username for authentication\n * @param {string} pass - The password for authentication\n * @return {any} The wrapped database connection object\n * @function wrapDocumentScope\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant wrapDocumentScope\n *   participant DB\n *   participant reAuth\n *   \n *   Client->>wrapDocumentScope: con, dbName, user, pass\n *   wrapDocumentScope->>DB: con.use(dbName)\n *   Note over wrapDocumentScope: Wrap DB methods with re-auth\n *   \n *   loop For each method (insert, get, put, destroy, find)\n *     wrapDocumentScope->>wrapDocumentScope: Store original method\n *     wrapDocumentScope->>wrapDocumentScope: Define new method with re-auth\n *   end\n *   \n *   wrapDocumentScope->>wrapDocumentScope: Add NATIVE property with con value\n *   wrapDocumentScope-->>Client: Return wrapped DB\n *   \n *   Note over Client: Later when client uses DB methods\n *   Client->>DB: Any wrapped method call\n *   DB->>reAuth: Authenticate before operation\n *   reAuth-->>DB: Authentication complete\n *   DB->>DB: Call original method\n *   DB-->>Client: Return result\n */\nexport function wrapDocumentScope(\n  con: any,\n  dbName: string,\n  user: string,\n  pass: string\n): any {\n  const db = con.use(dbName);\n  [\"insert\", \"get\", \"put\", \"destroy\", \"find\"].forEach((k) => {\n    const original = (db as Record<string, any>)[k];\n    Object.defineProperty(db, k, {\n      enumerable: false,\n      configurable: true,\n      value: async (...args: any[]) => {\n        await reAuth(con, user, pass);\n        return original.call(db, ...args);\n      },\n    });\n  });\n  Object.defineProperty(db, CouchDBKeys.NATIVE, {\n    enumerable: false,\n    configurable: false,\n    writable: false,\n    value: con,\n  });\n  return db;\n}\n\n/**\n * @description Tests if an attribute name is reserved in CouchDB\n * @summary Checks if an attribute name starts with an underscore, which indicates it's a reserved attribute in CouchDB\n * @param {string} attr - The attribute name to test\n * @return {RegExpMatchArray|null} The match result or null if no match\n * @function testReservedAttributes\n * @memberOf module:for-couchdb\n */\nexport function testReservedAttributes(attr: string) {\n  const regexp = /^_.*$/g;\n  return attr.match(regexp);\n}\n\n/**\n * @description Generates a name for a CouchDB index\n * @summary Creates a standardized name for a CouchDB index based on the table, attribute, compositions, and order\n * @param {string} attribute - The primary attribute for the index\n * @param {string} tableName - The name of the table\n * @param {string[]} [compositions] - Optional additional attributes to include in the index\n * @param {OrderDirection} [order] - Optional sort order for the index\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {string} The generated index name\n * @function generateIndexName\n * @memberOf module:for-couchdb\n */\nexport function generateIndexName(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): string {\n  const attr = [PersistenceKeys.INDEX, tableName, attribute];\n  if (compositions) attr.push(...compositions);\n  if (order) attr.push(order);\n  return attr.join(separator);\n}\n\n/**\n * @description Generates a CouchDB index configuration\n * @summary Creates a complete CreateIndexRequest object for defining a CouchDB index based on specified parameters\n * @param {string} attribute - The primary attribute for the index\n * @param {string} tableName - The name of the table\n * @param {string[]} [compositions] - Optional additional attributes to include in the index\n * @param {OrderDirection} [order] - Optional sort order for the index\n * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name\n * @return {CreateIndexRequest} The complete index configuration object\n * @function generateIndexDoc\n * @memberOf module:for-couchdb\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant generateIndexDoc\n *   participant generateIndexName\n *   \n *   Caller->>generateIndexDoc: attribute, tableName, compositions, order, separator\n *   \n *   Note over generateIndexDoc: Create partial filter selector\n *   generateIndexDoc->>generateIndexDoc: Set up filter for tableName\n *   \n *   alt order is specified\n *     Note over generateIndexDoc: Create ordered fields array\n *     generateIndexDoc->>generateIndexDoc: Create orderProp for attribute\n *     generateIndexDoc->>generateIndexDoc: Map compositions to ordered props\n *     generateIndexDoc->>generateIndexDoc: Create sortedTable for table field\n *     generateIndexDoc->>generateIndexDoc: Combine all ordered fields\n *   else\n *     Note over generateIndexDoc: Create simple fields array\n *     generateIndexDoc->>generateIndexDoc: Use attribute, compositions, and table as strings\n *   end\n *   \n *   generateIndexDoc->>generateIndexName: Generate index name\n *   generateIndexName-->>generateIndexDoc: Return name\n *   \n *   Note over generateIndexDoc: Create final index request\n *   generateIndexDoc-->>Caller: Return CreateIndexRequest\n */\nexport function generateIndexDoc(\n  attribute: string,\n  tableName: string,\n  compositions?: string[],\n  order?: OrderDirection,\n  separator = DefaultSeparator\n): CreateIndexRequest {\n  const partialFilterSelector: MangoSelector = {};\n  partialFilterSelector[CouchDBKeys.TABLE] = {} as MangoSelector;\n  (partialFilterSelector[CouchDBKeys.TABLE] as MangoSelector)[\n    CouchDBOperator.EQUAL\n  ] = tableName;\n  let fields: SortOrder[];\n  if (order) {\n    const orderProp: SortOrder = {};\n    orderProp[attribute] = order as \"asc\" | \"desc\";\n    const sortedCompositions: SortOrder[] = (compositions || []).map((c) => {\n      const r: SortOrder = {};\n      r[c] = order as \"asc\" | \"desc\";\n      return r;\n    });\n    const sortedTable: SortOrder = {};\n    sortedTable[CouchDBKeys.TABLE] = order as \"asc\" | \"desc\";\n    fields = [orderProp, ...sortedCompositions, sortedTable];\n  } else {\n    fields = [attribute, ...(compositions || []), CouchDBKeys.TABLE];\n  }\n  const name = generateIndexName(\n    attribute,\n    tableName,\n    compositions,\n    order,\n    separator\n  );\n  return {\n    index: {\n      fields: fields,\n      // partial_filter_selector: partialFilterSelector,\n    },\n    ddoc: [name, CouchDBKeys.DDOC].join(separator),\n    name: name,\n  };\n}\n"]}