@strapi/core 0.0.0-experimental.e576af447d9f97e89e24c6daa32d8f714376cd5f → 0.0.0-experimental.e5be7949a8aed02e6af3c5a8bb244f5512801ec4

package/dist/services/cron.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var nodeSchedule = require('node-schedule');
+var fp = require('lodash/fp');
+
+const createCronService = ()=>{
+    let jobsSpecs = [];
+    let running = false;
+    return {
+        add (tasks = {}) {
+            for (const taskExpression of Object.keys(tasks)){
+                const taskValue = tasks[taskExpression];
+                let fn;
+                let options;
+                let taskName;
+                if (fp.isFunction(taskValue)) {
+                    // don't use task name if key is the rule
+                    taskName = null;
+                    fn = taskValue.bind(tasks);
+                    options = taskExpression;
+                } else if (fp.isFunction(taskValue.task)) {
+                    // set task name if key is not the rule
+                    taskName = taskExpression;
+                    fn = taskValue.task.bind(taskValue);
+                    options = taskValue.options;
+                } else {
+                    throw new Error(`Could not schedule a cron job for "${taskExpression}": no function found.`);
+                }
+                const fnWithStrapi = (...args)=>fn({
+                        strapi
+                    }, ...args);
+                // const job = new Job(null, fnWithStrapi);
+                const job = new nodeSchedule.Job(fnWithStrapi);
+                jobsSpecs.push({
+                    job,
+                    options,
+                    name: taskName
+                });
+                if (running) {
+                    job.schedule(options);
+                }
+            }
+            return this;
+        },
+        remove (name) {
+            if (!name) throw new Error('You must provide a name to remove a cron job.');
+            const matchingJobsSpecs = jobsSpecs.filter(({ name: jobSpecName }, index)=>{
+                if (jobSpecName === name) {
+                    jobsSpecs.splice(index, 1);
+                    return true;
+                }
+                return false;
+            });
+            matchingJobsSpecs.forEach(({ job })=>job.cancel());
+            return this;
+        },
+        start () {
+            jobsSpecs.forEach(({ job, options })=>job.schedule(options));
+            running = true;
+            return this;
+        },
+        stop () {
+            jobsSpecs.forEach(({ job })=>job.cancel());
+            running = false;
+            return this;
+        },
+        destroy () {
+            this.stop();
+            jobsSpecs = [];
+            return this;
+        },
+        jobs: jobsSpecs
+    };
+};
+
+module.exports = createCronService;
+//# sourceMappingURL=cron.js.map

package/dist/services/cron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.js","sources":["../../src/services/cron.ts"],"sourcesContent":["import { Job, Spec } from 'node-schedule';\nimport { isFunction } from 'lodash/fp';\nimport type { Core } from '@strapi/types';\n\ninterface JobSpec {\n  job: Job;\n  options: Spec;\n  name: string | null;\n}\n\ntype TaskFn = ({ strapi }: { strapi: Core.Strapi }, ...args: unknown[]) => Promise<unknown>;\n\ntype Task =\n  | TaskFn\n  | {\n      task: TaskFn;\n      options: Spec;\n    };\n\ninterface Tasks {\n  [key: string]: Task;\n}\n\nconst createCronService = () => {\n  let jobsSpecs: JobSpec[] = [];\n  let running = false;\n\n  return {\n    add(tasks: Tasks = {}) {\n      for (const taskExpression of Object.keys(tasks)) {\n        const taskValue = tasks[taskExpression];\n\n        let fn: TaskFn;\n        let options: Spec;\n        let taskName: string | null;\n        if (isFunction(taskValue)) {\n          // don't use task name if key is the rule\n          taskName = null;\n          fn = taskValue.bind(tasks);\n          options = taskExpression;\n        } else if (isFunction(taskValue.task)) {\n          // set task name if key is not the rule\n          taskName = taskExpression;\n          fn = taskValue.task.bind(taskValue);\n          options = taskValue.options;\n        } else {\n          throw new Error(\n            `Could not schedule a cron job for \"${taskExpression}\": no function found.`\n          );\n        }\n\n        const fnWithStrapi = (...args: unknown[]) => fn({ strapi }, ...args);\n\n        // const job = new Job(null, fnWithStrapi);\n        const job = new Job(fnWithStrapi);\n        jobsSpecs.push({ job, options, name: taskName });\n\n        if (running) {\n          job.schedule(options);\n        }\n      }\n      return this;\n    },\n\n    remove(name: string) {\n      if (!name) throw new Error('You must provide a name to remove a cron job.');\n      const matchingJobsSpecs = jobsSpecs.filter(({ name: jobSpecName }, index) => {\n        if (jobSpecName === name) {\n          jobsSpecs.splice(index, 1);\n          return true;\n        }\n        return false;\n      });\n      matchingJobsSpecs.forEach(({ job }) => job.cancel());\n      return this;\n    },\n\n    start() {\n      jobsSpecs.forEach(({ job, options }) => job.schedule(options));\n      running = true;\n      return this;\n    },\n\n    stop() {\n      jobsSpecs.forEach(({ job }) => job.cancel());\n      running = false;\n      return this;\n    },\n\n    destroy() {\n      this.stop();\n      jobsSpecs = [];\n      return this;\n    },\n    jobs: jobsSpecs,\n  };\n};\n\nexport default createCronService;\n"],"names":["createCronService","jobsSpecs","running","add","tasks","taskExpression","Object","keys","taskValue","fn","options","taskName","isFunction","bind","task","Error","fnWithStrapi","args","strapi","job","Job","push","name","schedule","remove","matchingJobsSpecs","filter","jobSpecName","index","splice","forEach","cancel","start","stop","destroy","jobs"],"mappings":"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"}

package/dist/services/cron.mjs

@@ -0,0 +1,75 @@
+import { Job } from 'node-schedule';
+import { isFunction } from 'lodash/fp';
+
+const createCronService = ()=>{
+    let jobsSpecs = [];
+    let running = false;
+    return {
+        add (tasks = {}) {
+            for (const taskExpression of Object.keys(tasks)){
+                const taskValue = tasks[taskExpression];
+                let fn;
+                let options;
+                let taskName;
+                if (isFunction(taskValue)) {
+                    // don't use task name if key is the rule
+                    taskName = null;
+                    fn = taskValue.bind(tasks);
+                    options = taskExpression;
+                } else if (isFunction(taskValue.task)) {
+                    // set task name if key is not the rule
+                    taskName = taskExpression;
+                    fn = taskValue.task.bind(taskValue);
+                    options = taskValue.options;
+                } else {
+                    throw new Error(`Could not schedule a cron job for "${taskExpression}": no function found.`);
+                }
+                const fnWithStrapi = (...args)=>fn({
+                        strapi
+                    }, ...args);
+                // const job = new Job(null, fnWithStrapi);
+                const job = new Job(fnWithStrapi);
+                jobsSpecs.push({
+                    job,
+                    options,
+                    name: taskName
+                });
+                if (running) {
+                    job.schedule(options);
+                }
+            }
+            return this;
+        },
+        remove (name) {
+            if (!name) throw new Error('You must provide a name to remove a cron job.');
+            const matchingJobsSpecs = jobsSpecs.filter(({ name: jobSpecName }, index)=>{
+                if (jobSpecName === name) {
+                    jobsSpecs.splice(index, 1);
+                    return true;
+                }
+                return false;
+            });
+            matchingJobsSpecs.forEach(({ job })=>job.cancel());
+            return this;
+        },
+        start () {
+            jobsSpecs.forEach(({ job, options })=>job.schedule(options));
+            running = true;
+            return this;
+        },
+        stop () {
+            jobsSpecs.forEach(({ job })=>job.cancel());
+            running = false;
+            return this;
+        },
+        destroy () {
+            this.stop();
+            jobsSpecs = [];
+            return this;
+        },
+        jobs: jobsSpecs
+    };
+};
+
+export { createCronService as default };
+//# sourceMappingURL=cron.mjs.map

package/dist/services/cron.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.mjs","sources":["../../src/services/cron.ts"],"sourcesContent":["import { Job, Spec } from 'node-schedule';\nimport { isFunction } from 'lodash/fp';\nimport type { Core } from '@strapi/types';\n\ninterface JobSpec {\n  job: Job;\n  options: Spec;\n  name: string | null;\n}\n\ntype TaskFn = ({ strapi }: { strapi: Core.Strapi }, ...args: unknown[]) => Promise<unknown>;\n\ntype Task =\n  | TaskFn\n  | {\n      task: TaskFn;\n      options: Spec;\n    };\n\ninterface Tasks {\n  [key: string]: Task;\n}\n\nconst createCronService = () => {\n  let jobsSpecs: JobSpec[] = [];\n  let running = false;\n\n  return {\n    add(tasks: Tasks = {}) {\n      for (const taskExpression of Object.keys(tasks)) {\n        const taskValue = tasks[taskExpression];\n\n        let fn: TaskFn;\n        let options: Spec;\n        let taskName: string | null;\n        if (isFunction(taskValue)) {\n          // don't use task name if key is the rule\n          taskName = null;\n          fn = taskValue.bind(tasks);\n          options = taskExpression;\n        } else if (isFunction(taskValue.task)) {\n          // set task name if key is not the rule\n          taskName = taskExpression;\n          fn = taskValue.task.bind(taskValue);\n          options = taskValue.options;\n        } else {\n          throw new Error(\n            `Could not schedule a cron job for \"${taskExpression}\": no function found.`\n          );\n        }\n\n        const fnWithStrapi = (...args: unknown[]) => fn({ strapi }, ...args);\n\n        // const job = new Job(null, fnWithStrapi);\n        const job = new Job(fnWithStrapi);\n        jobsSpecs.push({ job, options, name: taskName });\n\n        if (running) {\n          job.schedule(options);\n        }\n      }\n      return this;\n    },\n\n    remove(name: string) {\n      if (!name) throw new Error('You must provide a name to remove a cron job.');\n      const matchingJobsSpecs = jobsSpecs.filter(({ name: jobSpecName }, index) => {\n        if (jobSpecName === name) {\n          jobsSpecs.splice(index, 1);\n          return true;\n        }\n        return false;\n      });\n      matchingJobsSpecs.forEach(({ job }) => job.cancel());\n      return this;\n    },\n\n    start() {\n      jobsSpecs.forEach(({ job, options }) => job.schedule(options));\n      running = true;\n      return this;\n    },\n\n    stop() {\n      jobsSpecs.forEach(({ job }) => job.cancel());\n      running = false;\n      return this;\n    },\n\n    destroy() {\n      this.stop();\n      jobsSpecs = [];\n      return this;\n    },\n    jobs: jobsSpecs,\n  };\n};\n\nexport default createCronService;\n"],"names":["createCronService","jobsSpecs","running","add","tasks","taskExpression","Object","keys","taskValue","fn","options","taskName","isFunction","bind","task","Error","fnWithStrapi","args","strapi","job","Job","push","name","schedule","remove","matchingJobsSpecs","filter","jobSpecName","index","splice","forEach","cancel","start","stop","destroy","jobs"],"mappings":"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"}

package/dist/services/custom-fields.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const createCustomFields = (strapi)=>{
+    return {
+        register (customField) {
+            strapi.get('custom-fields').add(customField);
+        }
+    };
+};
+
+module.exports = createCustomFields;
+//# sourceMappingURL=custom-fields.js.map

package/dist/services/custom-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-fields.js","sources":["../../src/services/custom-fields.ts"],"sourcesContent":["import type { Core, Modules } from '@strapi/types';\n\nconst createCustomFields = (strapi: Core.Strapi): Modules.CustomFields.CustomFields => {\n  return {\n    register(customField) {\n      strapi.get('custom-fields').add(customField);\n    },\n  };\n};\n\nexport default createCustomFields;\n"],"names":["createCustomFields","strapi","register","customField","get","add"],"mappings":";;AAEA,MAAMA,qBAAqB,CAACC,MAAAA,GAAAA;IAC1B,OAAO;AACLC,QAAAA,QAAAA,CAAAA,CAASC,WAAW,EAAA;AAClBF,YAAAA,MAAAA,CAAOG,GAAG,CAAC,eAAiBC,CAAAA,CAAAA,GAAG,CAACF,WAAAA,CAAAA;AAClC;AACF,KAAA;AACF;;;;"}

package/dist/services/custom-fields.mjs

@@ -0,0 +1,10 @@
+const createCustomFields = (strapi)=>{
+    return {
+        register (customField) {
+            strapi.get('custom-fields').add(customField);
+        }
+    };
+};
+
+export { createCustomFields as default };
+//# sourceMappingURL=custom-fields.mjs.map

package/dist/services/custom-fields.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-fields.mjs","sources":["../../src/services/custom-fields.ts"],"sourcesContent":["import type { Core, Modules } from '@strapi/types';\n\nconst createCustomFields = (strapi: Core.Strapi): Modules.CustomFields.CustomFields => {\n  return {\n    register(customField) {\n      strapi.get('custom-fields').add(customField);\n    },\n  };\n};\n\nexport default createCustomFields;\n"],"names":["createCustomFields","strapi","register","customField","get","add"],"mappings":"AAEA,MAAMA,qBAAqB,CAACC,MAAAA,GAAAA;IAC1B,OAAO;AACLC,QAAAA,QAAAA,CAAAA,CAASC,WAAW,EAAA;AAClBF,YAAAA,MAAAA,CAAOG,GAAG,CAAC,eAAiBC,CAAAA,CAAAA,GAAG,CAACF,WAAAA,CAAAA;AAClC;AACF,KAAA;AACF;;;;"}

package/dist/services/document-service/attributes/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var transforms = require('./transforms.js');
+
+const applyTransforms = fp.curry((schema, data)=>{
+    const attributeNames = Object.keys(data);
+    for (const attributeName of attributeNames){
+        const value = data[attributeName];
+        const attribute = schema.attributes[attributeName];
+        if (!attribute) {
+            continue;
+        }
+        const transform = transforms[attribute.type];
+        if (transform) {
+            const attributeContext = {
+                attributeName,
+                attribute
+            };
+            data[attributeName] = transform(value, attributeContext);
+        }
+    }
+    return data;
+});
+
+exports.applyTransforms = applyTransforms;
+//# sourceMappingURL=index.js.map

package/dist/services/document-service/attributes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/services/document-service/attributes/index.ts"],"sourcesContent":["import { curry } from 'lodash/fp';\n\nimport type { UID, Modules, Schema } from '@strapi/types';\n\nimport transforms from './transforms';\n\n// aliasing the type to make it easier to read\ntype Data = Modules.Documents.Params.Data.Input<UID.Schema>;\n\nconst applyTransforms = curry((schema: Schema.Schema, data: Data) => {\n  const attributeNames = Object.keys(data) as Array<keyof typeof data & string>;\n\n  for (const attributeName of attributeNames) {\n    const value = data[attributeName];\n\n    const attribute = schema.attributes[attributeName];\n\n    if (!attribute) {\n      continue;\n    }\n\n    const transform = transforms[attribute.type];\n\n    if (transform) {\n      const attributeContext = { attributeName, attribute };\n\n      data[attributeName] = transform(value, attributeContext);\n    }\n  }\n\n  return data;\n});\n\nexport { applyTransforms };\n"],"names":["applyTransforms","curry","schema","data","attributeNames","Object","keys","attributeName","value","attribute","attributes","transform","transforms","type","attributeContext"],"mappings":";;;;;AASMA,MAAAA,eAAAA,GAAkBC,QAAM,CAAA,CAACC,MAAuBC,EAAAA,IAAAA,GAAAA;IACpD,MAAMC,cAAAA,GAAiBC,MAAOC,CAAAA,IAAI,CAACH,IAAAA,CAAAA;IAEnC,KAAK,MAAMI,iBAAiBH,cAAgB,CAAA;QAC1C,MAAMI,KAAAA,GAAQL,IAAI,CAACI,aAAc,CAAA;AAEjC,QAAA,MAAME,SAAYP,GAAAA,MAAAA,CAAOQ,UAAU,CAACH,aAAc,CAAA;AAElD,QAAA,IAAI,CAACE,SAAW,EAAA;AACd,YAAA;AACF;AAEA,QAAA,MAAME,SAAYC,GAAAA,UAAU,CAACH,SAAAA,CAAUI,IAAI,CAAC;AAE5C,QAAA,IAAIF,SAAW,EAAA;AACb,YAAA,MAAMG,gBAAmB,GAAA;AAAEP,gBAAAA,aAAAA;AAAeE,gBAAAA;AAAU,aAAA;AAEpDN,YAAAA,IAAI,CAACI,aAAAA,CAAc,GAAGI,SAAAA,CAAUH,KAAOM,EAAAA,gBAAAA,CAAAA;AACzC;AACF;IAEA,OAAOX,IAAAA;AACT,CAAA;;;;"}

package/dist/services/document-service/attributes/index.mjs

@@ -0,0 +1,25 @@
+import { curry } from 'lodash/fp';
+import transforms from './transforms.mjs';
+
+const applyTransforms = curry((schema, data)=>{
+    const attributeNames = Object.keys(data);
+    for (const attributeName of attributeNames){
+        const value = data[attributeName];
+        const attribute = schema.attributes[attributeName];
+        if (!attribute) {
+            continue;
+        }
+        const transform = transforms[attribute.type];
+        if (transform) {
+            const attributeContext = {
+                attributeName,
+                attribute
+            };
+            data[attributeName] = transform(value, attributeContext);
+        }
+    }
+    return data;
+});
+
+export { applyTransforms };
+//# sourceMappingURL=index.mjs.map

package/dist/services/document-service/attributes/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../src/services/document-service/attributes/index.ts"],"sourcesContent":["import { curry } from 'lodash/fp';\n\nimport type { UID, Modules, Schema } from '@strapi/types';\n\nimport transforms from './transforms';\n\n// aliasing the type to make it easier to read\ntype Data = Modules.Documents.Params.Data.Input<UID.Schema>;\n\nconst applyTransforms = curry((schema: Schema.Schema, data: Data) => {\n  const attributeNames = Object.keys(data) as Array<keyof typeof data & string>;\n\n  for (const attributeName of attributeNames) {\n    const value = data[attributeName];\n\n    const attribute = schema.attributes[attributeName];\n\n    if (!attribute) {\n      continue;\n    }\n\n    const transform = transforms[attribute.type];\n\n    if (transform) {\n      const attributeContext = { attributeName, attribute };\n\n      data[attributeName] = transform(value, attributeContext);\n    }\n  }\n\n  return data;\n});\n\nexport { applyTransforms };\n"],"names":["applyTransforms","curry","schema","data","attributeNames","Object","keys","attributeName","value","attribute","attributes","transform","transforms","type","attributeContext"],"mappings":";;;AASMA,MAAAA,eAAAA,GAAkBC,KAAM,CAAA,CAACC,MAAuBC,EAAAA,IAAAA,GAAAA;IACpD,MAAMC,cAAAA,GAAiBC,MAAOC,CAAAA,IAAI,CAACH,IAAAA,CAAAA;IAEnC,KAAK,MAAMI,iBAAiBH,cAAgB,CAAA;QAC1C,MAAMI,KAAAA,GAAQL,IAAI,CAACI,aAAc,CAAA;AAEjC,QAAA,MAAME,SAAYP,GAAAA,MAAAA,CAAOQ,UAAU,CAACH,aAAc,CAAA;AAElD,QAAA,IAAI,CAACE,SAAW,EAAA;AACd,YAAA;AACF;AAEA,QAAA,MAAME,SAAYC,GAAAA,UAAU,CAACH,SAAAA,CAAUI,IAAI,CAAC;AAE5C,QAAA,IAAIF,SAAW,EAAA;AACb,YAAA,MAAMG,gBAAmB,GAAA;AAAEP,gBAAAA,aAAAA;AAAeE,gBAAAA;AAAU,aAAA;AAEpDN,YAAAA,IAAI,CAACI,aAAAA,CAAc,GAAGI,SAAAA,CAAUH,KAAOM,EAAAA,gBAAAA,CAAAA;AACzC;AACF;IAEA,OAAOX,IAAAA;AACT,CAAA;;;;"}

package/dist/services/document-service/attributes/transforms.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var bcrypt = require('bcryptjs');
+
+const transforms = {
+    password (value, context) {
+        const { attribute } = context;
+        if (attribute.type !== 'password') {
+            throw new Error('Invalid attribute type');
+        }
+        if (!fp.isString(value) && !(value instanceof Buffer)) {
+            return value;
+        }
+        const rounds = fp.toNumber(fp.getOr(10, 'encryption.rounds', attribute));
+        return bcrypt.hashSync(value.toString(), rounds);
+    }
+};
+
+module.exports = transforms;
+//# sourceMappingURL=transforms.js.map

package/dist/services/document-service/attributes/transforms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.js","sources":["../../../../src/services/document-service/attributes/transforms.ts"],"sourcesContent":["import { getOr, toNumber, isString } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport bcrypt from 'bcryptjs';\n\ntype Transforms = {\n  [TKind in Schema.Attribute.Kind]?: (\n    value: unknown,\n    context: {\n      attribute: Schema.Attribute.AnyAttribute;\n      attributeName: string;\n    }\n  ) => any;\n};\n\nconst transforms: Transforms = {\n  password(value, context) {\n    const { attribute } = context;\n\n    if (attribute.type !== 'password') {\n      throw new Error('Invalid attribute type');\n    }\n\n    if (!isString(value) && !(value instanceof Buffer)) {\n      return value;\n    }\n\n    const rounds = toNumber(getOr(10, 'encryption.rounds', attribute));\n\n    return bcrypt.hashSync(value.toString(), rounds);\n  },\n};\n\nexport default transforms;\n"],"names":["transforms","password","value","context","attribute","type","Error","isString","Buffer","rounds","toNumber","getOr","bcrypt","hashSync","toString"],"mappings":";;;;;AAcA,MAAMA,UAAyB,GAAA;IAC7BC,QAASC,CAAAA,CAAAA,KAAK,EAAEC,OAAO,EAAA;QACrB,MAAM,EAAEC,SAAS,EAAE,GAAGD,OAAAA;QAEtB,IAAIC,SAAAA,CAAUC,IAAI,KAAK,UAAY,EAAA;AACjC,YAAA,MAAM,IAAIC,KAAM,CAAA,wBAAA,CAAA;AAClB;AAEA,QAAA,IAAI,CAACC,WAASL,CAAAA,KAAAA,CAAAA,IAAU,EAAEA,KAAAA,YAAiBM,MAAK,CAAI,EAAA;YAClD,OAAON,KAAAA;AACT;AAEA,QAAA,MAAMO,MAASC,GAAAA,WAAAA,CAASC,QAAM,CAAA,EAAA,EAAI,mBAAqBP,EAAAA,SAAAA,CAAAA,CAAAA;AAEvD,QAAA,OAAOQ,MAAOC,CAAAA,QAAQ,CAACX,KAAAA,CAAMY,QAAQ,EAAIL,EAAAA,MAAAA,CAAAA;AAC3C;AACF;;;;"}

package/dist/services/document-service/attributes/transforms.mjs

@@ -0,0 +1,19 @@
+import { isString, toNumber, getOr } from 'lodash/fp';
+import bcrypt from 'bcryptjs';
+
+const transforms = {
+    password (value, context) {
+        const { attribute } = context;
+        if (attribute.type !== 'password') {
+            throw new Error('Invalid attribute type');
+        }
+        if (!isString(value) && !(value instanceof Buffer)) {
+            return value;
+        }
+        const rounds = toNumber(getOr(10, 'encryption.rounds', attribute));
+        return bcrypt.hashSync(value.toString(), rounds);
+    }
+};
+
+export { transforms as default };
+//# sourceMappingURL=transforms.mjs.map

package/dist/services/document-service/attributes/transforms.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.mjs","sources":["../../../../src/services/document-service/attributes/transforms.ts"],"sourcesContent":["import { getOr, toNumber, isString } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport bcrypt from 'bcryptjs';\n\ntype Transforms = {\n  [TKind in Schema.Attribute.Kind]?: (\n    value: unknown,\n    context: {\n      attribute: Schema.Attribute.AnyAttribute;\n      attributeName: string;\n    }\n  ) => any;\n};\n\nconst transforms: Transforms = {\n  password(value, context) {\n    const { attribute } = context;\n\n    if (attribute.type !== 'password') {\n      throw new Error('Invalid attribute type');\n    }\n\n    if (!isString(value) && !(value instanceof Buffer)) {\n      return value;\n    }\n\n    const rounds = toNumber(getOr(10, 'encryption.rounds', attribute));\n\n    return bcrypt.hashSync(value.toString(), rounds);\n  },\n};\n\nexport default transforms;\n"],"names":["transforms","password","value","context","attribute","type","Error","isString","Buffer","rounds","toNumber","getOr","bcrypt","hashSync","toString"],"mappings":";;;AAcA,MAAMA,UAAyB,GAAA;IAC7BC,QAASC,CAAAA,CAAAA,KAAK,EAAEC,OAAO,EAAA;QACrB,MAAM,EAAEC,SAAS,EAAE,GAAGD,OAAAA;QAEtB,IAAIC,SAAAA,CAAUC,IAAI,KAAK,UAAY,EAAA;AACjC,YAAA,MAAM,IAAIC,KAAM,CAAA,wBAAA,CAAA;AAClB;AAEA,QAAA,IAAI,CAACC,QAASL,CAAAA,KAAAA,CAAAA,IAAU,EAAEA,KAAAA,YAAiBM,MAAK,CAAI,EAAA;YAClD,OAAON,KAAAA;AACT;AAEA,QAAA,MAAMO,MAASC,GAAAA,QAAAA,CAASC,KAAM,CAAA,EAAA,EAAI,mBAAqBP,EAAAA,SAAAA,CAAAA,CAAAA;AAEvD,QAAA,OAAOQ,MAAOC,CAAAA,QAAQ,CAACX,KAAAA,CAAMY,QAAQ,EAAIL,EAAAA,MAAAA,CAAAA;AAC3C;AACF;;;;"}

package/dist/services/document-service/common.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const wrapInTransaction = (fn)=>{
+    return (...args)=>strapi.db.transaction?.(()=>fn(...args));
+};
+
+exports.wrapInTransaction = wrapInTransaction;
+//# sourceMappingURL=common.js.map

package/dist/services/document-service/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sources":["../../../src/services/document-service/common.ts"],"sourcesContent":["import type { UID, Modules } from '@strapi/types';\n\nexport type RepositoryFactoryMethod = <TContentTypeUID extends UID.ContentType>(\n  uid: TContentTypeUID,\n  entityValidator: Modules.EntityValidator.EntityValidator\n) => Modules.Documents.ServiceInstance<TContentTypeUID>;\n\nexport const wrapInTransaction = (fn: (...args: any) => any) => {\n  return (...args: any[]) => strapi.db.transaction?.(() => fn(...args));\n};\n"],"names":["wrapInTransaction","fn","args","strapi","db","transaction"],"mappings":";;AAOO,MAAMA,oBAAoB,CAACC,EAAAA,GAAAA;IAChC,OAAO,CAAC,GAAGC,IAAgBC,GAAAA,MAAAA,CAAOC,EAAE,CAACC,WAAW,GAAG,IAAMJ,EAAMC,CAAAA,GAAAA,IAAAA,CAAAA,CAAAA;AACjE;;;;"}

package/dist/services/document-service/common.mjs

@@ -0,0 +1,6 @@
+const wrapInTransaction = (fn)=>{
+    return (...args)=>strapi.db.transaction?.(()=>fn(...args));
+};
+
+export { wrapInTransaction };
+//# sourceMappingURL=common.mjs.map

package/dist/services/document-service/common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.mjs","sources":["../../../src/services/document-service/common.ts"],"sourcesContent":["import type { UID, Modules } from '@strapi/types';\n\nexport type RepositoryFactoryMethod = <TContentTypeUID extends UID.ContentType>(\n  uid: TContentTypeUID,\n  entityValidator: Modules.EntityValidator.EntityValidator\n) => Modules.Documents.ServiceInstance<TContentTypeUID>;\n\nexport const wrapInTransaction = (fn: (...args: any) => any) => {\n  return (...args: any[]) => strapi.db.transaction?.(() => fn(...args));\n};\n"],"names":["wrapInTransaction","fn","args","strapi","db","transaction"],"mappings":"AAOO,MAAMA,oBAAoB,CAACC,EAAAA,GAAAA;IAChC,OAAO,CAAC,GAAGC,IAAgBC,GAAAA,MAAAA,CAAOC,EAAE,CAACC,WAAW,GAAG,IAAMJ,EAAMC,CAAAA,GAAAA,IAAAA,CAAAA,CAAAA;AACjE;;;;"}

package/dist/services/document-service/components.js

@@ -0,0 +1,286 @@
+'use strict';
+
+var _ = require('lodash');
+var fp = require('lodash/fp');
+var strapiUtils = require('@strapi/utils');
+
+const omitComponentData = fp.curry((schema, data)=>{
+    const { attributes } = schema;
+    const componentAttributes = Object.keys(attributes).filter((attributeName)=>strapiUtils.contentTypes.isComponentAttribute(attributes[attributeName]));
+    return fp.omit(componentAttributes, data);
+});
+// NOTE: we could generalize the logic to allow CRUD of relation directly in the DB layer
+const createComponents = async (uid, data)=>{
+    const { attributes = {} } = strapi.getModel(uid);
+    const componentBody = {};
+    const attributeNames = Object.keys(attributes);
+    for (const attributeName of attributeNames){
+        const attribute = attributes[attributeName];
+        if (!fp.has(attributeName, data) || !strapiUtils.contentTypes.isComponentAttribute(attribute)) {
+            continue;
+        }
+        if (attribute.type === 'component') {
+            const { component: componentUID, repeatable = false } = attribute;
+            const componentValue = data[attributeName];
+            if (componentValue === null) {
+                continue;
+            }
+            if (repeatable === true) {
+                if (!Array.isArray(componentValue)) {
+                    throw new Error('Expected an array to create repeatable component');
+                }
+                const components = await strapiUtils.async.map(componentValue, (value)=>createComponent(componentUID, value));
+                componentBody[attributeName] = components.map(({ id })=>{
+                    return {
+                        id,
+                        __pivot: {
+                            field: attributeName,
+                            component_type: componentUID
+                        }
+                    };
+                });
+            } else {
+                const component = await createComponent(componentUID, componentValue);
+                componentBody[attributeName] = {
+                    id: component.id,
+                    __pivot: {
+                        field: attributeName,
+                        component_type: componentUID
+                    }
+                };
+            }
+            continue;
+        }
+        if (attribute.type === 'dynamiczone') {
+            const dynamiczoneValues = data[attributeName];
+            if (!Array.isArray(dynamiczoneValues)) {
+                throw new Error('Expected an array to create repeatable component');
+            }
+            const createDynamicZoneComponents = async (value)=>{
+                const { id } = await createComponent(value.__component, value);
+                return {
+                    id,
+                    __component: value.__component,
+                    __pivot: {
+                        field: attributeName
+                    }
+                };
+            };
+            // MySQL/MariaDB can cause deadlocks here if concurrency higher than 1
+            componentBody[attributeName] = await strapiUtils.async.map(dynamiczoneValues, createDynamicZoneComponents);
+            continue;
+        }
+    }
+    return componentBody;
+};
+const getComponents = async (uid, entity)=>{
+    const componentAttributes = strapiUtils.contentTypes.getComponentAttributes(strapi.getModel(uid));
+    if (_.isEmpty(componentAttributes)) {
+        return {};
+    }
+    return strapi.db.query(uid).load(entity, componentAttributes);
+};
+/*
+  delete old components
+  create or update
+*/ const updateComponents = async (uid, entityToUpdate, data)=>{
+    const { attributes = {} } = strapi.getModel(uid);
+    const componentBody = {};
+    for (const attributeName of Object.keys(attributes)){
+        const attribute = attributes[attributeName];
+        if (!fp.has(attributeName, data)) {
+            continue;
+        }
+        if (attribute.type === 'component') {
+            const { component: componentUID, repeatable = false } = attribute;
+            const componentValue = data[attributeName];
+            await deleteOldComponents(uid, componentUID, entityToUpdate, attributeName, componentValue);
+            if (repeatable === true) {
+                if (!Array.isArray(componentValue)) {
+                    throw new Error('Expected an array to create repeatable component');
+                }
+                // MySQL/MariaDB can cause deadlocks here if concurrency higher than 1
+                const components = await strapiUtils.async.map(componentValue, (value)=>updateOrCreateComponent(componentUID, value));
+                componentBody[attributeName] = components.filter(_.negate(_.isNil)).map(({ id })=>{
+                    return {
+                        id,
+                        __pivot: {
+                            field: attributeName,
+                            component_type: componentUID
+                        }
+                    };
+                });
+            } else {
+                const component = await updateOrCreateComponent(componentUID, componentValue);
+                componentBody[attributeName] = component && {
+                    id: component.id,
+                    __pivot: {
+                        field: attributeName,
+                        component_type: componentUID
+                    }
+                };
+            }
+        } else if (attribute.type === 'dynamiczone') {
+            const dynamiczoneValues = data[attributeName];
+            await deleteOldDZComponents(uid, entityToUpdate, attributeName, dynamiczoneValues);
+            if (!Array.isArray(dynamiczoneValues)) {
+                throw new Error('Expected an array to create repeatable component');
+            }
+            // MySQL/MariaDB can cause deadlocks here if concurrency higher than 1
+            componentBody[attributeName] = await strapiUtils.async.map(dynamiczoneValues, async (value)=>{
+                const { id } = await updateOrCreateComponent(value.__component, value);
+                return {
+                    id,
+                    __component: value.__component,
+                    __pivot: {
+                        field: attributeName
+                    }
+                };
+            });
+        }
+    }
+    return componentBody;
+};
+const pickStringifiedId = ({ id })=>{
+    if (typeof id === 'string') {
+        return id;
+    }
+    return `${id}`;
+};
+const deleteOldComponents = async (uid, componentUID, entityToUpdate, attributeName, componentValue)=>{
+    const previousValue = await strapi.db.query(uid).load(entityToUpdate, attributeName);
+    const idsToKeep = _.castArray(componentValue).filter(fp.has('id')).map(pickStringifiedId);
+    const allIds = _.castArray(previousValue).filter(fp.has('id')).map(pickStringifiedId);
+    idsToKeep.forEach((id)=>{
+        if (!allIds.includes(id)) {
+            throw new strapiUtils.errors.ApplicationError(`Some of the provided components in ${attributeName} are not related to the entity`);
+        }
+    });
+    const idsToDelete = _.difference(allIds, idsToKeep);
+    if (idsToDelete.length > 0) {
+        for (const idToDelete of idsToDelete){
+            await deleteComponent(componentUID, {
+                id: idToDelete
+            });
+        }
+    }
+};
+const deleteOldDZComponents = async (uid, entityToUpdate, attributeName, dynamiczoneValues)=>{
+    const previousValue = await strapi.db.query(uid).load(entityToUpdate, attributeName);
+    const idsToKeep = _.castArray(dynamiczoneValues).filter(fp.has('id')).map((v)=>({
+            id: pickStringifiedId(v),
+            __component: v.__component
+        }));
+    const allIds = _.castArray(previousValue).filter(fp.has('id')).map((v)=>({
+            id: pickStringifiedId(v),
+            __component: v.__component
+        }));
+    idsToKeep.forEach(({ id, __component })=>{
+        if (!allIds.find((el)=>el.id === id && el.__component === __component)) {
+            const err = new Error(`Some of the provided components in ${attributeName} are not related to the entity`);
+            Object.assign(err, {
+                status: 400
+            });
+            throw err;
+        }
+    });
+    const idsToDelete = allIds.reduce((acc, { id, __component })=>{
+        if (!idsToKeep.find((el)=>el.id === id && el.__component === __component)) {
+            acc.push({
+                id,
+                __component
+            });
+        }
+        return acc;
+    }, []);
+    if (idsToDelete.length > 0) {
+        for (const idToDelete of idsToDelete){
+            const { id, __component } = idToDelete;
+            await deleteComponent(__component, {
+                id
+            });
+        }
+    }
+};
+const deleteComponents = async (uid, entityToDelete, { loadComponents = true } = {})=>{
+    const { attributes = {} } = strapi.getModel(uid);
+    const attributeNames = Object.keys(attributes);
+    for (const attributeName of attributeNames){
+        const attribute = attributes[attributeName];
+        if (attribute.type === 'component' || attribute.type === 'dynamiczone') {
+            let value;
+            if (loadComponents) {
+                value = await strapi.db.query(uid).load(entityToDelete, attributeName);
+            } else {
+                value = entityToDelete[attributeName];
+            }
+            if (!value) {
+                continue;
+            }
+            if (attribute.type === 'component') {
+                const { component: componentUID } = attribute;
+                await strapiUtils.async.map(_.castArray(value), (subValue)=>deleteComponent(componentUID, subValue));
+            } else {
+                await strapiUtils.async.map(_.castArray(value), (subValue)=>deleteComponent(subValue.__component, subValue));
+            }
+            continue;
+        }
+    }
+};
+/** *************************
+    Component queries
+************************** */ // components can have nested compos so this must be recursive
+const createComponent = async (uid, data)=>{
+    const schema = strapi.getModel(uid);
+    const componentData = await createComponents(uid, data);
+    const transform = fp.pipe(// Make sure we don't save the component with a pre-defined ID
+    fp.omit('id'), assignComponentData(schema, componentData));
+    return strapi.db.query(uid).create({
+        data: transform(data)
+    });
+};
+// components can have nested compos so this must be recursive
+const updateComponent = async (uid, componentToUpdate, data)=>{
+    const schema = strapi.getModel(uid);
+    const componentData = await updateComponents(uid, componentToUpdate, data);
+    return strapi.db.query(uid).update({
+        where: {
+            id: componentToUpdate.id
+        },
+        data: assignComponentData(schema, componentData, data)
+    });
+};
+const updateOrCreateComponent = (componentUID, value)=>{
+    if (value === null) {
+        return null;
+    }
+    // update
+    if ('id' in value && typeof value.id !== 'undefined') {
+        // TODO: verify the compo is associated with the entity
+        return updateComponent(componentUID, {
+            id: value.id
+        }, value);
+    }
+    // create
+    return createComponent(componentUID, value);
+};
+const deleteComponent = async (uid, componentToDelete)=>{
+    await deleteComponents(uid, componentToDelete);
+    await strapi.db.query(uid).delete({
+        where: {
+            id: componentToDelete.id
+        }
+    });
+};
+const assignComponentData = fp.curry((schema, componentData, data)=>{
+    return fp.pipe(omitComponentData(schema), fp.assign(componentData))(data);
+});
+
+exports.assignComponentData = assignComponentData;
+exports.createComponents = createComponents;
+exports.deleteComponent = deleteComponent;
+exports.deleteComponents = deleteComponents;
+exports.getComponents = getComponents;
+exports.omitComponentData = omitComponentData;
+exports.updateComponents = updateComponents;
+//# sourceMappingURL=components.js.map