@decaf-ts/db-decorators 0.2.0 → 0.3.1

package/lib/esm/repository/utils.js

@@ -1 +1,167 @@
-import{Operations}from"../operations/Operations";import{OperationKeys}from"../operations/constants";import{getAllPropertyDecorators}from"@decaf-ts/reflection";import{InternalError}from"./errors";import{ModelKeys,sf}from"@decaf-ts/decorator-validation";const getHandlerArgs=function(e,r,t,o){var n=t.constructor.name;if(!n)throw new InternalError("Could not determine model class");o=o||{},e.props.handlers[n]&&e.props.handlers[n][r]&&(o={...e.props.handlers[n][r],...o});let a=Object.getPrototypeOf(t);return a===Object.prototype?o:(a.constructor.name===n&&(a=Object.getPrototypeOf(a)),getHandlerArgs(e,r,a,o))};async function enforceDBDecorators(r,t,o,e,n){var a=getDbDecorators(t,o,e);if(a)for(const f in a)for(const d of a[f]){var s=d["key"],i=Operations.get(t,f,e+s);if(!i||!i.length)throw new InternalError(`Could not find registered handler for the operation ${e+s} under property `+f);var p=getHandlerArgs(d,f,t);if(!p||Object.values(p).length!==i.length)throw new InternalError(sf("Args and handlers length do not match"));for(let e=0;e<i.length;e++){var c=i[e],l=[Object.values(p)[e].data,f,t];if(o===OperationKeys.UPDATE){if(!n)throw new InternalError("Missing old model for update operation");l.push(n)}await c.apply(r,l)}}}function getDbDecorators(e,o,r){const n=getAllPropertyDecorators(e,OperationKeys.REFLECT+(r||""));if(n)return Object.keys(n).reduce((e,r)=>{var t=n[r].filter(e=>e.key===o);return t&&t.length&&((e=e||{})[r]=t),e},void 0)}const getAllPropertyDecoratorsRecursive=function(e,r,...t){const s=r||{};function o(e){Object.entries(e).forEach(([e,r])=>{var a;s[e]=s[e]||[],[a,...e]=[e,...r],e.forEach(r=>{var e;if((e=s[a].find(e=>e.key===r.key))&&e.props.operation===r.props.operation){if(r.key!==ModelKeys.TYPE){var{handlers:t,operation:o}=r.props;if(o&&o.match(new RegExp(`^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`))){const n=e.props.handlers;Object.entries(t).forEach(([o,e])=>{o in n?Object.entries(e).forEach(([t,e])=>{t in n[o]?Object.entries(e).forEach(([e,r])=>{e in n[o][t]?console.warn(sf("Skipping handler registration for {0} under prop {0} because handler is the same",o,t)):n[o][t][e]=r}):n[o][t]=e}):n[o]=e})}else s[a].push(r)}}else s[a].push(r)})})}var r=getAllPropertyDecorators(e,...t);return r&&o(r),Object.getPrototypeOf(e)!==Object.prototype&&(r=Object.getPrototypeOf(e))?getAllPropertyDecoratorsRecursive(r,s,...t):s};export{getHandlerArgs,enforceDBDecorators,getDbDecorators,getAllPropertyDecoratorsRecursive};
+import { Operations } from "../operations/Operations";
+import { OperationKeys } from "../operations/constants";
+import { getAllPropertyDecorators, } from "@decaf-ts/reflection";
+import { InternalError } from "./errors";
+import { ModelKeys, sf } from "@decaf-ts/decorator-validation";
+/**
+ * @summary retrieves the arguments for the handler
+ * @param {any} dec the decorator
+ * @param {string} prop the property name
+ * @param {{}} m the model
+ * @param {{}} [accum] accumulator used for internal recursiveness
+ *
+ * @function getHandlerArgs
+ * @memberOf module:db-decorators.Repository
+ */
+export const getHandlerArgs = function (dec, prop, m, accum) {
+    const name = m.constructor.name;
+    if (!name)
+        throw new InternalError("Could not determine model class");
+    accum = accum || {};
+    if (dec.props.handlers[name] && dec.props.handlers[name][prop])
+        accum = { ...dec.props.handlers[name][prop], ...accum };
+    let proto = Object.getPrototypeOf(m);
+    if (proto === Object.prototype)
+        return accum;
+    if (proto.constructor.name === name)
+        proto = Object.getPrototypeOf(proto);
+    return getHandlerArgs(dec, prop, proto, accum);
+};
+/**
+ *
+ * @param {IRepository<T>} repo
+ * @param {T} model
+ * @param operation
+ * @param prefix
+ *
+ * @param oldModel
+ * @function enforceDBPropertyDecoratorsAsync
+ *
+ * @memberOf db-decorators.utils
+ */
+export async function enforceDBDecorators(repo, model, operation, prefix, oldModel) {
+    const decorators = getDbDecorators(model, operation, prefix);
+    if (!decorators)
+        return;
+    for (const prop in decorators) {
+        const decs = decorators[prop];
+        for (const dec of decs) {
+            const { key } = dec;
+            const handlers = Operations.get(model, prop, prefix + key);
+            if (!handlers || !handlers.length)
+                throw new InternalError(`Could not find registered handler for the operation ${prefix + key} under property ${prop}`);
+            const handlerArgs = getHandlerArgs(dec, prop, model);
+            if (!handlerArgs || Object.values(handlerArgs).length !== handlers.length)
+                throw new InternalError(sf("Args and handlers length do not match"));
+            let handler;
+            let data;
+            for (let i = 0; i < handlers.length; i++) {
+                handler = handlers[i];
+                data = Object.values(handlerArgs)[i];
+                const args = [data.data, prop, model];
+                if (operation === OperationKeys.UPDATE) {
+                    if (!oldModel)
+                        throw new InternalError("Missing old model for update operation");
+                    args.push(oldModel);
+                }
+                await handler.apply(repo, args);
+            }
+        }
+    }
+}
+/**
+ * Specific for DB Decorators
+ * @param {T} model
+ * @param {string} operation CRUD {@link OperationKeys}
+ * @param {string} [extraPrefix]
+ *
+ * @function getDbPropertyDecorators
+ *
+ * @memberOf db-decorators.utils
+ */
+export function getDbDecorators(model, operation, extraPrefix) {
+    const decorators = getAllPropertyDecorators(model, 
+    // undefined,
+    OperationKeys.REFLECT + (extraPrefix ? extraPrefix : ""));
+    if (!decorators)
+        return;
+    return Object.keys(decorators).reduce((accum, decorator) => {
+        const dec = decorators[decorator].filter((d) => d.key === operation);
+        if (dec && dec.length) {
+            if (!accum)
+                accum = {};
+            accum[decorator] = dec;
+        }
+        return accum;
+    }, undefined);
+}
+/**
+ * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively
+ * @param model
+ * @param accum
+ * @param prefixes
+ *
+ * @function getAllPropertyDecoratorsRecursive
+ * @memberOf module:db-decorators.Repository
+ */
+export const getAllPropertyDecoratorsRecursive = function (model, accum, ...prefixes) {
+    const accumulator = accum || {};
+    const mergeDecorators = function (decs) {
+        const pushOrSquash = (key, ...values) => {
+            values.forEach((val) => {
+                let match;
+                if (!(match = accumulator[key].find((e) => e.key === val.key)) ||
+                    match.props.operation !== val.props.operation) {
+                    accumulator[key].push(val);
+                    return;
+                }
+                if (val.key === ModelKeys.TYPE)
+                    return;
+                const { handlers, operation } = val.props;
+                if (!operation ||
+                    !operation.match(new RegExp(`^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`))) {
+                    accumulator[key].push(val);
+                    return;
+                }
+                const accumHandlers = match.props.handlers;
+                Object.entries(handlers).forEach(([clazz, handlerDef]) => {
+                    if (!(clazz in accumHandlers)) {
+                        accumHandlers[clazz] = handlerDef;
+                        return;
+                    }
+                    Object.entries(handlerDef).forEach(([handlerProp, handler]) => {
+                        if (!(handlerProp in accumHandlers[clazz])) {
+                            accumHandlers[clazz][handlerProp] = handler;
+                            return;
+                        }
+                        Object.entries(handler).forEach(([handlerKey, argsObj]) => {
+                            if (!(handlerKey in accumHandlers[clazz][handlerProp])) {
+                                accumHandlers[clazz][handlerProp][handlerKey] = argsObj;
+                                return;
+                            }
+                            console.warn(sf("Skipping handler registration for {0} under prop {0} because handler is the same", clazz, handlerProp));
+                        });
+                    });
+                });
+            });
+        };
+        Object.entries(decs).forEach(([key, value]) => {
+            accumulator[key] = accumulator[key] || [];
+            pushOrSquash(key, ...value);
+        });
+    };
+    const decs = getAllPropertyDecorators(model, ...prefixes);
+    if (decs)
+        mergeDecorators(decs);
+    if (Object.getPrototypeOf(model) === Object.prototype)
+        return accumulator;
+    // const name = model.constructor.name;
+    const proto = Object.getPrototypeOf(model);
+    if (!proto)
+        return accumulator;
+    // if (proto.constructor && proto.constructor.name === name)
+    //     proto = Object.getPrototypeOf(proto)
+    return getAllPropertyDecoratorsRecursive(proto, accumulator, ...prefixes);
+};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/repository/utils.ts"],"names":[],"mappings":"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","file":"repository/utils.js","sourcesContent":["import { Operations } from \"../operations/Operations\";\nimport { OperationHandler, UpdateOperationHandler } from \"../operations/types\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { OperationKeys } from \"../operations/constants\";\nimport {\n  DecoratorMetadata,\n  getAllPropertyDecorators,\n} from \"@decaf-ts/reflection\";\nimport { InternalError } from \"./errors\";\nimport { Constructor, ModelKeys, sf } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary retrieves the arguments for the handler\n * @param {any} dec the decorator\n * @param {string} prop the property name\n * @param {{}} m the model\n * @param {{}} [accum] accumulator used for internal recursiveness\n *\n * @function getHandlerArgs\n * @memberOf module:db-decorators.Repository\n */\nexport const getHandlerArgs = function (\n  dec: any,\n  prop: string,\n  m: Constructor<any>,\n  accum?: Record<string, { args: string[] }>\n): Record<string, { args: string[] }> | void {\n  const name = m.constructor.name;\n  if (!name) throw new InternalError(\"Could not determine model class\");\n  accum = accum || {};\n\n  if (dec.props.handlers[name] && dec.props.handlers[name][prop])\n    accum = { ...dec.props.handlers[name][prop], ...accum };\n\n  let proto = Object.getPrototypeOf(m);\n  if (proto === Object.prototype) return accum;\n  if (proto.constructor.name === name) proto = Object.getPrototypeOf(proto);\n\n  return getHandlerArgs(dec, prop, proto, accum);\n};\n\n/**\n *\n * @param {IRepository<T>} repo\n * @param {T} model\n * @param operation\n * @param prefix\n *\n * @param oldModel\n * @function enforceDBPropertyDecoratorsAsync\n *\n * @memberOf db-decorators.utils\n */\nexport async function enforceDBDecorators<\n  T extends Model,\n  Y extends IRepository<T>,\n  V,\n>(\n  repo: Y,\n  model: T,\n  operation: string,\n  prefix: string,\n  oldModel?: T\n): Promise<void> {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    getDbDecorators(model, operation, prefix);\n\n  if (!decorators) return;\n\n  for (const prop in decorators) {\n    const decs: DecoratorMetadata[] = decorators[prop];\n    for (const dec of decs) {\n      const { key } = dec;\n      const handlers: OperationHandler<T, Y, V>[] | undefined = Operations.get(\n        model,\n        prop,\n        prefix + key\n      );\n      if (!handlers || !handlers.length)\n        throw new InternalError(\n          `Could not find registered handler for the operation ${prefix + key} under property ${prop}`\n        );\n\n      const handlerArgs = getHandlerArgs(dec, prop, model as any);\n\n      if (!handlerArgs || Object.values(handlerArgs).length !== handlers.length)\n        throw new InternalError(sf(\"Args and handlers length do not match\"));\n\n      let handler: OperationHandler<any, any, any>;\n      let data: any;\n      for (let i = 0; i < handlers.length; i++) {\n        handler = handlers[i];\n        data = Object.values(handlerArgs)[i];\n\n        const args: any[] = [data.data, prop, model];\n\n        if (operation === OperationKeys.UPDATE) {\n          if (!oldModel)\n            throw new InternalError(\"Missing old model for update operation\");\n          args.push(oldModel);\n        }\n        await (handler as UpdateOperationHandler<T, Y, V>).apply(\n          repo,\n          args as [V, any, T, T]\n        );\n      }\n    }\n  }\n}\n\n/**\n * Specific for DB Decorators\n * @param {T} model\n * @param {string} operation CRUD {@link OperationKeys}\n * @param {string} [extraPrefix]\n *\n * @function getDbPropertyDecorators\n *\n * @memberOf db-decorators.utils\n */\nexport function getDbDecorators<T extends Model>(\n  model: T,\n  operation: string,\n  extraPrefix?: string\n): Record<string, DecoratorMetadata[]> | undefined {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    getAllPropertyDecorators(\n      model,\n      // undefined,\n      OperationKeys.REFLECT + (extraPrefix ? extraPrefix : \"\")\n    );\n  if (!decorators) return;\n  return Object.keys(decorators).reduce(\n    (accum: Record<string, DecoratorMetadata[]> | undefined, decorator) => {\n      const dec = decorators[decorator].filter((d) => d.key === operation);\n      if (dec && dec.length) {\n        if (!accum) accum = {};\n        accum[decorator] = dec;\n      }\n      return accum;\n    },\n    undefined\n  );\n}\n\n/**\n * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively\n * @param model\n * @param accum\n * @param prefixes\n *\n * @function getAllPropertyDecoratorsRecursive\n * @memberOf module:db-decorators.Repository\n */\nexport const getAllPropertyDecoratorsRecursive = function <T extends Model>(\n  model: T,\n  accum: { [indexer: string]: any[] } | undefined,\n  ...prefixes: string[]\n): { [indexer: string]: any[] } | undefined {\n  const accumulator = accum || {};\n  const mergeDecorators = function (decs: { [indexer: string]: any[] }) {\n    const pushOrSquash = (key: string, ...values: any[]) => {\n      values.forEach((val) => {\n        let match: any;\n        if (\n          !(match = accumulator[key].find((e) => e.key === val.key)) ||\n          match.props.operation !== val.props.operation\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        if (val.key === ModelKeys.TYPE) return;\n\n        const { handlers, operation } = val.props;\n\n        if (\n          !operation ||\n          !operation.match(\n            new RegExp(\n              `^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`\n            )\n          )\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        const accumHandlers = match.props.handlers;\n\n        Object.entries(handlers).forEach(([clazz, handlerDef]) => {\n          if (!(clazz in accumHandlers)) {\n            accumHandlers[clazz] = handlerDef;\n            return;\n          }\n\n          Object.entries(handlerDef as object).forEach(\n            ([handlerProp, handler]) => {\n              if (!(handlerProp in accumHandlers[clazz])) {\n                accumHandlers[clazz][handlerProp] = handler;\n                return;\n              }\n\n              Object.entries(handler as object).forEach(\n                ([handlerKey, argsObj]) => {\n                  if (!(handlerKey in accumHandlers[clazz][handlerProp])) {\n                    accumHandlers[clazz][handlerProp][handlerKey] = argsObj;\n                    return;\n                  }\n                  console.warn(\n                    sf(\n                      \"Skipping handler registration for {0} under prop {0} because handler is the same\",\n                      clazz,\n                      handlerProp\n                    )\n                  );\n                }\n              );\n            }\n          );\n        });\n      });\n    };\n\n    Object.entries(decs).forEach(([key, value]) => {\n      accumulator[key] = accumulator[key] || [];\n      pushOrSquash(key, ...value);\n    });\n  };\n\n  const decs: { [indexer: string]: any[] } | undefined =\n    getAllPropertyDecorators(model, ...prefixes);\n  if (decs) mergeDecorators(decs);\n\n  if (Object.getPrototypeOf(model) === Object.prototype) return accumulator;\n\n  // const name = model.constructor.name;\n  const proto = Object.getPrototypeOf(model);\n  if (!proto) return accumulator;\n  // if (proto.constructor && proto.constructor.name === name)\n  //     proto = Object.getPrototypeOf(proto)\n  return getAllPropertyDecoratorsRecursive(proto, accumulator, ...prefixes);\n};\n"]}

package/lib/esm/repository/wrappers.js

@@ -1 +1,90 @@
-function prefixMethod(e,a,r,i){var n=async function(...e){return e=await Promise.resolve(r.call(this,...e)),Promise.resolve(a.apply(this,e))}.bind(e),i=i||a.name;Object.defineProperty(n,"name",{enumerable:!0,configurable:!0,writable:!1,value:i}),e[i]=n}function suffixMethod(e,a,r,i){var n=async function(...e){return e=await Promise.resolve(a.call(this,...e)),r.call(this,...e)}.bind(e),i=i||a.name;Object.defineProperty(n,"name",{enumerable:!0,configurable:!0,writable:!1,value:i}),e[i]=n}function wrapMethod(a,r,i,n,e){var t=async function(...e){return e=await Promise.resolve(r.call(a,...e)),e=await Promise.resolve(i.call(a,...e)),Promise.resolve(n.call(this,e))}.bind(a),e=e||i.name;Object.defineProperty(t,"name",{enumerable:!0,configurable:!0,writable:!1,value:e}),a[e]=t}export{prefixMethod,suffixMethod,wrapMethod};
+/**
+ * @summary Util method to change a method of an object prefixing it with another
+ * @param {any} obj The Base Object
+ * @param {Function} after The original method
+ * @param {Function} prefix The Prefix method. The output will be used as arguments in the original method
+ * @param {string} [afterName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function prefixMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export function prefixMethod(obj, after, prefix, afterName) {
+    async function wrapper(...args) {
+        const results = await Promise.resolve(prefix.call(this, ...args));
+        return Promise.resolve(after.apply(this, results));
+    }
+    const wrapped = wrapper.bind(obj);
+    const name = afterName ? afterName : after.name;
+    Object.defineProperty(wrapped, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: false,
+        value: name,
+    });
+    obj[name] = wrapped;
+}
+/**
+ * @summary Util method to change a method of an object suffixing it with another
+ * @param {any} obj The Base Object
+ * @param {Function} before The original method
+ * @param {Function} suffix The Prefix method. The output will be used as arguments in the original method
+ * @param {string} [beforeName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function suffixMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export function suffixMethod(obj, before, suffix, beforeName) {
+    async function wrapper(...args) {
+        const results = await Promise.resolve(before.call(this, ...args));
+        return suffix.call(this, ...results);
+    }
+    const wrapped = wrapper.bind(obj);
+    const name = beforeName ? beforeName : before.name;
+    Object.defineProperty(wrapped, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: false,
+        value: name,
+    });
+    obj[name] = wrapped;
+}
+/**
+ * @summary Util method to wrap a method of an object with additional logic
+ *
+ * @param {any} obj The Base Object
+ * @param {Function} before the method to be prefixed
+ * @param {Function} method the method to be wrapped
+ * @param {Function} after The method to be suffixed
+ * @param {string} [methodName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function wrapMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export function wrapMethod(obj, before, method, after, methodName) {
+    async function wrapper(...args) {
+        let transformedArgs = before.call(obj, ...args);
+        if (transformedArgs instanceof Promise)
+            transformedArgs = await transformedArgs;
+        let results = await method.call(obj, ...transformedArgs);
+        if (results instanceof Promise)
+            results = await results;
+        results = after.call(this, results);
+        if (results instanceof Promise)
+            results = await results;
+        return results;
+    }
+    const wrapped = wrapper.bind(obj);
+    const name = methodName ? methodName : method.name;
+    Object.defineProperty(wrapped, "name", {
+        enumerable: true,
+        configurable: true,
+        writable: false,
+        value: name,
+    });
+    obj[name] = wrapped;
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/validation/constants.js

@@ -1 +1,33 @@
-import{DBKeys}from"../model/constants";const DEFAULT_ERROR_MESSAGES={ID:{INVALID:"This Id is invalid",REQUIRED:"The Id is mandatory"},READONLY:{INVALID:"This cannot be updated"},TIMESTAMP:{REQUIRED:"Timestamp is Mandatory",DATE:"The Timestamp must the a valid date",INVALID:"This value must always increase"}},UpdateValidationKeys={REFLECT:"db.update.validation.",TIMESTAMP:DBKeys.TIMESTAMP,READONLY:DBKeys.READONLY};export{DEFAULT_ERROR_MESSAGES,UpdateValidationKeys};
+import { DBKeys } from "../model/constants";
+/**
+ * @summary holds the default error messages
+ * @const DEFAULT_ERROR_MESSAGES
+ *
+ * @memberOf module:db-decorators.Model
+ */
+export const DEFAULT_ERROR_MESSAGES = {
+    ID: {
+        INVALID: "This Id is invalid",
+        REQUIRED: "The Id is mandatory",
+    },
+    READONLY: {
+        INVALID: "This cannot be updated",
+    },
+    TIMESTAMP: {
+        REQUIRED: "Timestamp is Mandatory",
+        DATE: "The Timestamp must the a valid date",
+        INVALID: "This value must always increase",
+    },
+};
+/**
+ * @summary Update reflection keys
+ * @const UpdateValidationKeys
+ * @memberOf module:db-decorators.Operations
+ */
+export const UpdateValidationKeys = {
+    REFLECT: "db.update.validation.",
+    TIMESTAMP: DBKeys.TIMESTAMP,
+    READONLY: DBKeys.READONLY,
+};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy92YWxpZGF0aW9uL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFNUM7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRztJQUNwQyxFQUFFLEVBQUU7UUFDRixPQUFPLEVBQUUsb0JBQW9CO1FBQzdCLFFBQVEsRUFBRSxxQkFBcUI7S0FDaEM7SUFDRCxRQUFRLEVBQUU7UUFDUixPQUFPLEVBQUUsd0JBQXdCO0tBQ2xDO0lBQ0QsU0FBUyxFQUFFO1FBQ1QsUUFBUSxFQUFFLHdCQUF3QjtRQUNsQyxJQUFJLEVBQUUscUNBQXFDO1FBQzNDLE9BQU8sRUFBRSxpQ0FBaUM7S0FDM0M7Q0FDRixDQUFDO0FBRUY7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHO0lBQ2xDLE9BQU8sRUFBRSx1QkFBdUI7SUFDaEMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxTQUFTO0lBQzNCLFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUTtDQUMxQixDQUFDIiwiZmlsZSI6InZhbGlkYXRpb24vY29uc3RhbnRzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgREJLZXlzIH0gZnJvbSBcIi4uL21vZGVsL2NvbnN0YW50c1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IGhvbGRzIHRoZSBkZWZhdWx0IGVycm9yIG1lc3NhZ2VzXG4gKiBAY29uc3QgREVGQVVMVF9FUlJPUl9NRVNTQUdFU1xuICpcbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGItZGVjb3JhdG9ycy5Nb2RlbFxuICovXG5leHBvcnQgY29uc3QgREVGQVVMVF9FUlJPUl9NRVNTQUdFUyA9IHtcbiAgSUQ6IHtcbiAgICBJTlZBTElEOiBcIlRoaXMgSWQgaXMgaW52YWxpZFwiLFxuICAgIFJFUVVJUkVEOiBcIlRoZSBJZCBpcyBtYW5kYXRvcnlcIixcbiAgfSxcbiAgUkVBRE9OTFk6IHtcbiAgICBJTlZBTElEOiBcIlRoaXMgY2Fubm90IGJlIHVwZGF0ZWRcIixcbiAgfSxcbiAgVElNRVNUQU1QOiB7XG4gICAgUkVRVUlSRUQ6IFwiVGltZXN0YW1wIGlzIE1hbmRhdG9yeVwiLFxuICAgIERBVEU6IFwiVGhlIFRpbWVzdGFtcCBtdXN0IHRoZSBhIHZhbGlkIGRhdGVcIixcbiAgICBJTlZBTElEOiBcIlRoaXMgdmFsdWUgbXVzdCBhbHdheXMgaW5jcmVhc2VcIixcbiAgfSxcbn07XG5cbi8qKlxuICogQHN1bW1hcnkgVXBkYXRlIHJlZmxlY3Rpb24ga2V5c1xuICogQGNvbnN0IFVwZGF0ZVZhbGlkYXRpb25LZXlzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRiLWRlY29yYXRvcnMuT3BlcmF0aW9uc1xuICovXG5leHBvcnQgY29uc3QgVXBkYXRlVmFsaWRhdGlvbktleXMgPSB7XG4gIFJFRkxFQ1Q6IFwiZGIudXBkYXRlLnZhbGlkYXRpb24uXCIsXG4gIFRJTUVTVEFNUDogREJLZXlzLlRJTUVTVEFNUCxcbiAgUkVBRE9OTFk6IERCS2V5cy5SRUFET05MWSxcbn07XG4iXX0=

package/lib/esm/validation/decorators.d.ts

@@ -1,7 +1,5 @@
 import { OperationKeys } from "../operations/constants";
 import { IRepository } from "../interfaces/IRepository";
-import { DBModel } from "../model/DBModel";
-import { CustomDecorator } from "@decaf-ts/reflection";
 export declare function getDBUpdateKey(str: string): string;
 /**
  * Marks the property as readonly.
@@ -12,8 +10,8 @@ export declare function getDBUpdateKey(str: string): string;
  *
  * @category Decorators
  */
-export declare function readonly(message?: string): CustomDecorator<V>;
-export declare function timestampHandler<T extends DBModel, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T): void;
+export declare function readonly(message?: string): PropertyDecorator;
+export declare function timestampHandler<T extends Model, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T): void;
 /**
  * Marks the property as timestamp.
  * Makes it {@link required}
@@ -45,9 +43,9 @@ export declare function timestampHandler<T extends DBModel, V extends IRepositor
  *
  * @category Decorators
  */
-export declare function timestamp(operation?: OperationKeys[], format?: string): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
-export declare function serializeOnCreateUpdate<T extends DBModel, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T, oldModel: T): Promise<void>;
-export declare function serializeAfterAll<T extends DBModel, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T): Promise<void>;
+export declare function timestamp(operation?: OperationKeys[], format?: string): (target: object, propertyKey?: any, descriptor?: any) => void;
+export declare function serializeOnCreateUpdate<T extends Model, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T, oldModel: T): Promise<void>;
+export declare function serializeAfterAll<T extends Model, V extends IRepository<T>, Y = any>(this: V, data: Y, key: string, model: T): Promise<void>;
 /**
  * @summary Serialize Decorator
  * @description properties decorated will the serialized before stored in the db
@@ -56,4 +54,4 @@ export declare function serializeAfterAll<T extends DBModel, V extends IReposito
  *
  * @memberOf module:wallet-db.Decorators
  */
-export declare function serialize(): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+export declare function serialize(): (target: object, propertyKey?: any, descriptor?: any) => void;

package/lib/esm/validation/decorators.js

@@ -1 +1,223 @@
-import{date,required,sf,type}from"@decaf-ts/decorator-validation";import{DBKeys,DEFAULT_TIMESTAMP_FORMAT}from"../model/constants";import{DEFAULT_ERROR_MESSAGES,UpdateValidationKeys}from"./constants";import{DBOperations,OperationKeys}from"../operations/constants";import{after,on,onCreateUpdate}from"../operations/decorators";import{SerializationError}from"../repository/errors";import{apply,metadata}from"@decaf-ts/reflection";import{getDBKey}from"../model/decorators";function getDBUpdateKey(e){return UpdateValidationKeys.REFLECT+e}function readonly(e=DEFAULT_ERROR_MESSAGES.READONLY.INVALID){return metadata(getDBUpdateKey(DBKeys.READONLY),{message:e})}function timestampHandler(e,t,r){r[t]=new Date}function timestamp(e=DBOperations.CREATE_UPDATE,t=DEFAULT_TIMESTAMP_FORMAT){t=[date(t,DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),required(DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),on(e,timestampHandler)];return-1!==e.indexOf(OperationKeys.UPDATE)&&t.push(metadata(getDBUpdateKey(DBKeys.TIMESTAMP),{message:DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID})),apply(...t)}async function serializeOnCreateUpdate(e,t,r,a){if(r[t])try{r[t]=JSON.stringify(r[t])}catch(e){throw new SerializationError(sf("Failed to serialize {0} property on {0} model",t,r.constructor.name))}}async function serializeAfterAll(e,t,r){if(r[t]&&"string"==typeof r[t])try{r[t]=JSON.parse(r[t])}catch(e){throw new SerializationError(sf("Failed to deserialize {0} property on {0} model",t,r.constructor.name))}}function serialize(){return apply(onCreateUpdate(serializeOnCreateUpdate),after(DBOperations.ALL,serializeAfterAll),type([String.name,Object.name]),metadata(getDBKey(DBKeys.SERIALIZE),{}))}export{getDBUpdateKey,readonly,timestampHandler,timestamp,serializeOnCreateUpdate,serializeAfterAll,serialize};
+import { date, propMetadata, required, sf, type, } from "@decaf-ts/decorator-validation";
+import { DBKeys, DEFAULT_TIMESTAMP_FORMAT } from "../model/constants";
+import { DEFAULT_ERROR_MESSAGES, UpdateValidationKeys } from "./constants";
+import { DBOperations, OperationKeys } from "../operations/constants";
+import { after, on, onCreateUpdate } from "../operations/decorators";
+import { SerializationError } from "../repository/errors";
+import { apply, metadata } from "@decaf-ts/reflection";
+import { Repository } from "../repository";
+export function getDBUpdateKey(str) {
+    return UpdateValidationKeys.REFLECT + str;
+}
+/**
+ * Marks the property as readonly.
+ *
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES.READONLY.INVALID}
+ *
+ * @decorator readonly
+ *
+ * @category Decorators
+ */
+export function readonly(message = DEFAULT_ERROR_MESSAGES.READONLY.INVALID) {
+    return propMetadata(getDBUpdateKey(DBKeys.READONLY), {
+        message: message,
+    });
+}
+export function timestampHandler(data, key, model) {
+    model[key] = new Date();
+}
+/**
+ * Marks the property as timestamp.
+ * Makes it {@link required}
+ * Makes it a {@link date}
+ *
+ * Date Format:
+ *
+ * <pre>
+ *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
+ *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
+ *      You can display date, time, AM/PM, etc.
+ *
+ *      Date and Time Patterns
+ *      yy = 2-digit year; yyyy = full year
+ *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
+ *      EEEE = full weekday name; EEE = short weekday name
+ *      d = digit day; dd = 2-digit day
+ *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
+ *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
+ *      s = seconds; ss = 2-digit seconds
+ *      S = miliseconds
+ * </pre>
+ *
+ * @param {string[]} operation The {@link DBOperations} to act on. Defaults to {@link DBOperations.CREATE_UPDATE}
+ * @param {string} [format] The TimeStamp format. defaults to {@link DEFAULT_TIMESTAMP_FORMAT}
+ * @param {{new: UpdateValidator}} [validator] defaults to {@link TimestampValidator}
+ *
+ * @decorator timestamp
+ *
+ * @category Decorators
+ */
+export function timestamp(operation = DBOperations.CREATE_UPDATE, format = DEFAULT_TIMESTAMP_FORMAT) {
+    const decorators = [
+        date(format, DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),
+        required(DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),
+        on(operation, timestampHandler),
+    ];
+    if (operation.indexOf(OperationKeys.UPDATE) !== -1)
+        decorators.push(metadata(getDBUpdateKey(DBKeys.TIMESTAMP), {
+            message: DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,
+        }));
+    return apply(...decorators);
+}
+export async function serializeOnCreateUpdate(data, key, model, oldModel) {
+    if (!model[key])
+        return;
+    try {
+        model[key] = JSON.stringify(model[key]);
+    }
+    catch (e) {
+        throw new SerializationError(sf("Failed to serialize {0} property on {1} model: {2}", key, model.constructor.name, e.message));
+    }
+}
+export async function serializeAfterAll(data, key, model) {
+    if (!model[key])
+        return;
+    if (typeof model[key] !== "string")
+        return;
+    try {
+        model[key] = JSON.parse(model[key]);
+    }
+    catch (e) {
+        throw new SerializationError(sf("Failed to deserialize {0} property on {1} model: {2}", key, model.constructor.name, e.message));
+    }
+}
+/**
+ * @summary Serialize Decorator
+ * @description properties decorated will the serialized before stored in the db
+ *
+ * @function serialize
+ *
+ * @memberOf module:wallet-db.Decorators
+ */
+export function serialize() {
+    return apply(onCreateUpdate(serializeOnCreateUpdate), after(DBOperations.ALL, serializeAfterAll), type([String.name, Object.name]), metadata(Repository.key(DBKeys.SERIALIZE), {}));
+}
+//
+// /**
+//  * @summary One To One relation Decorators
+//  *
+//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+//  * @param {CascadeMetadata} [cascadeOptions]
+//  * @param {boolean} _populate If true, replaces the specified key in the document with the corresponding record from the database
+//  *
+//  * @function onToOne
+//  *
+//  * @memberOf module:wallet-db.Decorators
+//  *
+//  * @see oneToMany
+//  * @see manyToOne
+//  */
+// export function oneToOne(
+//   clazz: Constructor<any>,
+//   cascadeOptions: CascadeMetadata = DefaultCascade,
+//   _populate: boolean = true,
+// ) {
+//   Model.register(clazz);
+//   return (target: any, propertyKey: string) => {
+//     type([clazz.name, String.name])(target, propertyKey);
+//     onCreate(oneToOneOnCreate)(target, propertyKey);
+//     onUpdate(oneToOneOnUpdate, cascadeOptions as any)(target, propertyKey);
+//     onDelete(oneToOneOnDelete, cascadeOptions)(target, propertyKey);
+//
+//     afterCreate(populate, _populate)(target, propertyKey);
+//     afterUpdate(populate, _populate)(target, propertyKey);
+//     afterRead(populate, _populate)(target, propertyKey);
+//     afterDelete(populate, _populate)(target, propertyKey);
+//
+//     Reflect.defineMetadata(
+//       getDBKey(WalletDbKeys.ONE_TO_ONE),
+//       {
+//         constructor: clazz.name,
+//         cascade: cascadeOptions,
+//         populate: _populate,
+//       },
+//       target,
+//       propertyKey,
+//     );
+//   };
+// }
+//
+// /**
+//  * @summary One To Many relation Decorators
+//  *
+//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+//  * @param {CascadeMetadata} [cascadeOptions]
+//  *
+//  * @function onToMany
+//  *
+//  * @memberOf module:wallet-db.Decorators
+//  *
+//  * @see oneToOne
+//  * @see manyToOne
+//  */
+// export function oneToMany(
+//   clazz: Constructor<any>,
+//   cascadeOptions: CascadeMetadata = DefaultCascade,
+//   _populate: boolean = true,
+// ) {
+//   Model.register(clazz);
+//   return (target: any, propertyKey: string) => {
+//     list([clazz, String])(target, propertyKey);
+//     onCreate(oneToManyOnCreate)(target, propertyKey);
+//     onUpdate(oneToManyOnUpdate, cascadeOptions)(target, propertyKey);
+//     onDelete(oneToManyOnDelete, cascadeOptions)(target, propertyKey);
+//
+//     afterCreate(populate, _populate)(target, propertyKey);
+//     afterUpdate(populate, _populate)(target, propertyKey);
+//     afterRead(populate, _populate)(target, propertyKey);
+//     afterDelete(populate, _populate)(target, propertyKey);
+//
+//     Reflect.defineMetadata(
+//       getDBKey(WalletDbKeys.ONE_TO_MANY),
+//       {
+//         constructor: clazz.name,
+//         cascade: cascadeOptions,
+//       },
+//       target,
+//       propertyKey,
+//     );
+//   };
+// }
+//
+// /**
+//  * @summary Many To One relation Decorators
+//  *
+//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+//  * @param {CascadeMetadata} [cascadeOptions]
+//  *
+//  * @function manyToOne
+//  *
+//  * @memberOf module:wallet-db.Decorators
+//  *
+//  * @see oneToMany
+//  * @see oneToOne
+//  */
+// export function manyToOne(
+//   clazz: Constructor<any>,
+//   cascadeOptions: CascadeMetadata = DefaultCascade,
+// ) {
+//   Model.register(clazz);
+//   return (target: any, propertyKey: string) => {
+//     Reflect.defineMetadata(
+//       getDBKey(WalletDbKeys.MANY_TO_ONE),
+//       {
+//         constructor: clazz.name,
+//         cascade: cascadeOptions,
+//       },
+//       target,
+//       propertyKey,
+//     );
+//   };
+// }
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/validation/decorators.ts"],"names":[],"mappings":"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","file":"validation/decorators.js","sourcesContent":["import {\n  date,\n  propMetadata,\n  required,\n  sf,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { DBKeys, DEFAULT_TIMESTAMP_FORMAT } from \"../model/constants\";\nimport { DEFAULT_ERROR_MESSAGES, UpdateValidationKeys } from \"./constants\";\nimport { DBOperations, OperationKeys } from \"../operations/constants\";\nimport { after, on, onCreateUpdate } from \"../operations/decorators\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { SerializationError } from \"../repository/errors\";\nimport { apply, CustomDecorator, metadata } from \"@decaf-ts/reflection\";\nimport { Repository } from \"../repository\";\n\nexport function getDBUpdateKey(str: string) {\n  return UpdateValidationKeys.REFLECT + str;\n}\n\n/**\n * Marks the property as readonly.\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES.READONLY.INVALID}\n *\n * @decorator readonly\n *\n * @category Decorators\n */\nexport function readonly(\n  message: string = DEFAULT_ERROR_MESSAGES.READONLY.INVALID\n) {\n  return propMetadata(getDBUpdateKey(DBKeys.READONLY), {\n    message: message,\n  });\n}\n\nexport function timestampHandler<\n  T extends Model,\n  V extends IRepository<T>,\n  Y = any,\n>(this: V, data: Y, key: string, model: T): void {\n  (model as any)[key] = new Date();\n}\n\n/**\n * Marks the property as timestamp.\n * Makes it {@link required}\n * Makes it a {@link date}\n *\n * Date Format:\n *\n * <pre>\n *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),\n *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.\n *      You can display date, time, AM/PM, etc.\n *\n *      Date and Time Patterns\n *      yy = 2-digit year; yyyy = full year\n *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name\n *      EEEE = full weekday name; EEE = short weekday name\n *      d = digit day; dd = 2-digit day\n *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours\n *      m = minutes; mm = 2-digit minutes; aaa = AM/PM\n *      s = seconds; ss = 2-digit seconds\n *      S = miliseconds\n * </pre>\n *\n * @param {string[]} operation The {@link DBOperations} to act on. Defaults to {@link DBOperations.CREATE_UPDATE}\n * @param {string} [format] The TimeStamp format. defaults to {@link DEFAULT_TIMESTAMP_FORMAT}\n * @param {{new: UpdateValidator}} [validator] defaults to {@link TimestampValidator}\n *\n * @decorator timestamp\n *\n * @category Decorators\n */\nexport function timestamp(\n  operation: OperationKeys[] = DBOperations.CREATE_UPDATE as unknown as OperationKeys[],\n  format: string = DEFAULT_TIMESTAMP_FORMAT\n) {\n  const decorators: CustomDecorator<any>[] = [\n    date(format, DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE) as CustomDecorator<any>,\n    required(DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED) as CustomDecorator<any>,\n    on(operation, timestampHandler) as CustomDecorator<any>,\n  ];\n\n  if (operation.indexOf(OperationKeys.UPDATE) !== -1)\n    decorators.push(\n      metadata(getDBUpdateKey(DBKeys.TIMESTAMP), {\n        message: DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,\n      })\n    );\n\n  return apply(...decorators);\n}\n\nexport async function serializeOnCreateUpdate<\n  T extends Model,\n  V extends IRepository<T>,\n  Y = any,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n>(this: V, data: Y, key: string, model: T, oldModel: T): Promise<void> {\n  if (!(model as any)[key]) return;\n  try {\n    (model as any)[key] = JSON.stringify((model as any)[key]);\n  } catch (e: any) {\n    throw new SerializationError(\n      sf(\n        \"Failed to serialize {0} property on {1} model: {2}\",\n        key,\n        model.constructor.name,\n        e.message\n      )\n    );\n  }\n}\n\nexport async function serializeAfterAll<\n  T extends Model,\n  V extends IRepository<T>,\n  Y = any,\n>(this: V, data: Y, key: string, model: T): Promise<void> {\n  if (!(model as any)[key]) return;\n  if (typeof (model as any)[key] !== \"string\") return;\n\n  try {\n    (model as any)[key] = JSON.parse((model as any)[key]);\n  } catch (e: any) {\n    throw new SerializationError(\n      sf(\n        \"Failed to deserialize {0} property on {1} model: {2}\",\n        key,\n        model.constructor.name,\n        e.message\n      )\n    );\n  }\n}\n\n/**\n * @summary Serialize Decorator\n * @description properties decorated will the serialized before stored in the db\n *\n * @function serialize\n *\n * @memberOf module:wallet-db.Decorators\n */\nexport function serialize() {\n  return apply(\n    onCreateUpdate(serializeOnCreateUpdate),\n    after(DBOperations.ALL, serializeAfterAll),\n    type([String.name, Object.name]),\n    metadata(Repository.key(DBKeys.SERIALIZE), {})\n  );\n}\n\n//\n// /**\n//  * @summary One To One relation Decorators\n//  *\n//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n//  * @param {CascadeMetadata} [cascadeOptions]\n//  * @param {boolean} _populate If true, replaces the specified key in the document with the corresponding record from the database\n//  *\n//  * @function onToOne\n//  *\n//  * @memberOf module:wallet-db.Decorators\n//  *\n//  * @see oneToMany\n//  * @see manyToOne\n//  */\n// export function oneToOne(\n//   clazz: Constructor<any>,\n//   cascadeOptions: CascadeMetadata = DefaultCascade,\n//   _populate: boolean = true,\n// ) {\n//   Model.register(clazz);\n//   return (target: any, propertyKey: string) => {\n//     type([clazz.name, String.name])(target, propertyKey);\n//     onCreate(oneToOneOnCreate)(target, propertyKey);\n//     onUpdate(oneToOneOnUpdate, cascadeOptions as any)(target, propertyKey);\n//     onDelete(oneToOneOnDelete, cascadeOptions)(target, propertyKey);\n//\n//     afterCreate(populate, _populate)(target, propertyKey);\n//     afterUpdate(populate, _populate)(target, propertyKey);\n//     afterRead(populate, _populate)(target, propertyKey);\n//     afterDelete(populate, _populate)(target, propertyKey);\n//\n//     Reflect.defineMetadata(\n//       getDBKey(WalletDbKeys.ONE_TO_ONE),\n//       {\n//         constructor: clazz.name,\n//         cascade: cascadeOptions,\n//         populate: _populate,\n//       },\n//       target,\n//       propertyKey,\n//     );\n//   };\n// }\n//\n// /**\n//  * @summary One To Many relation Decorators\n//  *\n//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n//  * @param {CascadeMetadata} [cascadeOptions]\n//  *\n//  * @function onToMany\n//  *\n//  * @memberOf module:wallet-db.Decorators\n//  *\n//  * @see oneToOne\n//  * @see manyToOne\n//  */\n// export function oneToMany(\n//   clazz: Constructor<any>,\n//   cascadeOptions: CascadeMetadata = DefaultCascade,\n//   _populate: boolean = true,\n// ) {\n//   Model.register(clazz);\n//   return (target: any, propertyKey: string) => {\n//     list([clazz, String])(target, propertyKey);\n//     onCreate(oneToManyOnCreate)(target, propertyKey);\n//     onUpdate(oneToManyOnUpdate, cascadeOptions)(target, propertyKey);\n//     onDelete(oneToManyOnDelete, cascadeOptions)(target, propertyKey);\n//\n//     afterCreate(populate, _populate)(target, propertyKey);\n//     afterUpdate(populate, _populate)(target, propertyKey);\n//     afterRead(populate, _populate)(target, propertyKey);\n//     afterDelete(populate, _populate)(target, propertyKey);\n//\n//     Reflect.defineMetadata(\n//       getDBKey(WalletDbKeys.ONE_TO_MANY),\n//       {\n//         constructor: clazz.name,\n//         cascade: cascadeOptions,\n//       },\n//       target,\n//       propertyKey,\n//     );\n//   };\n// }\n//\n// /**\n//  * @summary Many To One relation Decorators\n//  *\n//  * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n//  * @param {CascadeMetadata} [cascadeOptions]\n//  *\n//  * @function manyToOne\n//  *\n//  * @memberOf module:wallet-db.Decorators\n//  *\n//  * @see oneToMany\n//  * @see oneToOne\n//  */\n// export function manyToOne(\n//   clazz: Constructor<any>,\n//   cascadeOptions: CascadeMetadata = DefaultCascade,\n// ) {\n//   Model.register(clazz);\n//   return (target: any, propertyKey: string) => {\n//     Reflect.defineMetadata(\n//       getDBKey(WalletDbKeys.MANY_TO_ONE),\n//       {\n//         constructor: clazz.name,\n//         cascade: cascadeOptions,\n//       },\n//       target,\n//       propertyKey,\n//     );\n//   };\n// }\n"]}