@strapi/core 0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c → 0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de

package/dist/services/document-service/utils/unidirectional-relations.mjs

@@ -1,5 +1,5 @@
-import { keyBy } from "lodash/fp";
-const load = async (uid, oldEntries) => {
+import { omit, keyBy } from "lodash/fp";
+const load = async (uid, { oldVersions, newVersions }) => {
   const updates = [];
   await strapi.db.transaction(async ({ trx }) => {
     const contentTypes = Object.values(strapi.contentTypes);
@@ -7,21 +7,33 @@ const load = async (uid, oldEntries) => {
     for (const model of [...contentTypes, ...components]) {
       const dbModel = strapi.db.metadata.get(model.uid);
       for (const attribute of Object.values(dbModel.attributes)) {
-        if (attribute.type !== "relation")
-          continue;
-        if (attribute.target !== uid)
-          continue;
-        if (attribute.inversedBy || attribute.mappedBy)
+        if (attribute.type !== "relation" || attribute.target !== uid || attribute.inversedBy || attribute.mappedBy) {
           continue;
+        }
         const joinTable = attribute.joinTable;
-        if (!joinTable)
-          continue;
-        const { name } = joinTable.inverseJoinColumn;
-        const oldEntriesIds = oldEntries.map((entry) => entry.id);
-        const relations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(name, oldEntriesIds).transacting(trx);
-        if (relations.length === 0)
+        if (!joinTable) {
           continue;
-        updates.push({ joinTable, relations });
+        }
+        const { name: sourceColumnName } = joinTable.joinColumn;
+        const { name: targetColumnName } = joinTable.inverseJoinColumn;
+        const ids = oldVersions.map((entry) => entry.id);
+        const oldVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
+        if (oldVersionsRelations.length > 0) {
+          updates.push({ joinTable, relations: oldVersionsRelations });
+        }
+        if (!model.options?.draftAndPublish) {
+          const ids2 = newVersions.map((entry) => entry.id);
+          const newVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids2).transacting(trx);
+          if (newVersionsRelations.length > 0) {
+            const discardToAdd = newVersionsRelations.filter((relation) => {
+              const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {
+                return oldRelation[sourceColumnName] === relation[sourceColumnName];
+              });
+              return !matchingOldVerion;
+            }).map(omit("id"));
+            updates.push({ joinTable, relations: discardToAdd });
+          }
+        }
       }
     }
   });
@@ -41,8 +53,8 @@ const sync = async (oldEntries, newEntries, oldRelations) => {
   );
   await strapi.db.transaction(async ({ trx }) => {
     for (const { joinTable, relations } of oldRelations) {
+      const column = joinTable.inverseJoinColumn.name;
       const newRelations = relations.map((relation) => {
-        const column = joinTable.inverseJoinColumn.name;
         const newId = oldEntriesMap[relation[column]];
         return { ...relation, [column]: newId };
       });

package/dist/services/document-service/utils/unidirectional-relations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy } from 'lodash/fp';\n\nimport { UID, Schema } from '@strapi/types';\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n *\n * @param uid The content type uid\n * @param oldEntries The old entries that are being overridden\n * @returns An array of relations that need to be updated with the join table reference.\n */\nconst load = async (uid: UID.ContentType, oldEntries: { id: string; locale: string }[]) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (attribute.type !== 'relation') continue;\n        if (attribute.target !== uid) continue;\n        if (attribute.inversedBy || attribute.mappedBy) continue;\n        const joinTable = attribute.joinTable;\n        // TODO: joinColumn relations\n        if (!joinTable) continue;\n\n        const { name } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        const oldEntriesIds = oldEntries.map((entry) => entry.id);\n        const relations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(name, oldEntriesIds)\n          .transacting(trx);\n\n        if (relations.length === 0) continue;\n\n        updates.push({ joinTable, relations });\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const newRelations = relations.map((relation) => {\n        const column = joinTable.inverseJoinColumn.name;\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":[],"mappings":";AAcM,MAAA,OAAO,OAAO,KAAsB,eAAiD;AACzF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAIhE,YAAI,UAAU,SAAS;AAAY;AACnC,YAAI,UAAU,WAAW;AAAK;AAC1B,YAAA,UAAU,cAAc,UAAU;AAAU;AAChD,cAAM,YAAY,UAAU;AAE5B,YAAI,CAAC;AAAW;AAEV,cAAA,EAAE,KAAK,IAAI,UAAU;AAK3B,cAAM,gBAAgB,WAAW,IAAI,CAAC,UAAU,MAAM,EAAE;AACxD,cAAM,YAAY,MAAM,OAAO,GAC5B,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,MAAM,aAAa,EAC3B,YAAY,GAAG;AAElB,YAAI,UAAU,WAAW;AAAG;AAE5B,gBAAQ,KAAK,EAAE,WAAW,UAAW,CAAA;AAAA,MACvC;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmB,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAE7C,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAEnD,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AACzC,cAAA,SAAS,UAAU,kBAAkB;AAC3C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,cAAc,GAAI;AAAA,IAC1D;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"unidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport { UID, Schema } from '@strapi/types';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (uid: UID.ContentType, { oldVersions, newVersions }: LoadContext) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          if (newVersionsRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = newVersionsRelations\n              .filter((relation) => {\n                const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVerion;\n              })\n              .map(omit('id'));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["ids"],"mappings":";AAeA,MAAM,OAAO,OAAO,KAAsB,EAAE,aAAa,kBAA+B;AACtF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAK9D,YAAA,UAAU,SAAS,cACnB,UAAU,WAAW,OACrB,UAAU,cACV,UAAU,UACV;AACA;AAAA,QACF;AAGA,cAAM,YAAY,UAAU;AAC5B,YAAI,CAAC,WAAW;AACd;AAAA,QACF;AAEA,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAC7C,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAM7C,cAAM,MAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,cAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkB,GAAG,EAC7B,YAAY,GAAG;AAEd,YAAA,qBAAqB,SAAS,GAAG;AACnC,kBAAQ,KAAK,EAAE,WAAW,WAAW,qBAAsB,CAAA;AAAA,QAC7D;AAcI,YAAA,CAAC,MAAM,SAAS,iBAAiB;AACnC,gBAAMA,OAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,gBAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkBA,IAAG,EAC7B,YAAY,GAAG;AAEd,cAAA,qBAAqB,SAAS,GAAG;AAInC,kBAAM,eAAe,qBAClB,OAAO,CAAC,aAAa;AACpB,oBAAM,oBAAoB,qBAAqB,KAAK,CAAC,gBAAgB;AACnE,uBAAO,YAAY,gBAAgB,MAAM,SAAS,gBAAgB;AAAA,cAAA,CACnE;AAED,qBAAO,CAAC;AAAA,YACT,CAAA,EACA,IAAI,KAAK,IAAI,CAAC;AAEjB,oBAAQ,KAAK,EAAE,WAAW,WAAW,aAAc,CAAA;AAAA,UACrD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmB,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAE7C,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAE7C,YAAA,SAAS,UAAU,kBAAkB;AAE3C,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AAC/C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,cAAc,GAAI;AAAA,IAC1D;AAAA,EAAA,CACD;AACH;"}

package/dist/utils/transform-content-types-to-models.d.ts

@@ -20,47 +20,379 @@ export declare const getComponentJoinColumnInverseName: (identifiers: Identifier
 export declare const getComponentTypeColumn: (identifiers: Identifiers) => string;
 export declare const getComponentFkIndexName: (contentType: string, identifiers: Identifiers) => string;
 export type LoadedContentTypeModel = Struct.ContentTypeSchema & Required<Pick<Struct.ContentTypeSchema, 'collectionName' | 'uid' | 'modelName'>> & Pick<Model, 'lifecycles'>;
-export declare const transformAttribute: (name: string, attribute: Schema.Attribute.AnyAttribute, contentType: LoadedContentTypeModel, identifiers: Identifiers) => (Schema.Attribute.OfType<"biginteger"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxOption<string> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.UniqueOption) | (Schema.Attribute.OfType<"boolean"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<boolean> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"blocks"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"datetime"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<Schema.Attribute.DateTimeValue> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.UniqueOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"date"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<Schema.Attribute.DateValue> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.UniqueOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"decimal"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<number> & Schema.Attribute.MinMaxOption<number> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.UniqueOption) | (Schema.Attribute.OfType<"email"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.UniqueOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"enumeration"> & Schema.Attribute.EnumerationProperties<string[]> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"float"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<number> & Schema.Attribute.MinMaxOption<number> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.UniqueOption) | (Schema.Attribute.OfType<"integer"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<number> & Schema.Attribute.MinMaxOption<number> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.UniqueOption) | (Schema.Attribute.OfType<"json"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.RequiredOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.DefaultOption<import("@strapi/types/dist/utils").JSONPrimitive>) | (Schema.Attribute.OfType<"password"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+export declare const transformAttribute: (name: string, attribute: Schema.Attribute.AnyAttribute, contentType: LoadedContentTypeModel, identifiers: Identifiers) => {
+    type: "biginteger";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    min?: string | undefined;
+    max?: string | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    unique?: boolean | undefined;
+} | {
+    type: "boolean";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: boolean | (() => boolean) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "blocks";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "datetime";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: Schema.Attribute.DateTimeValue | (() => Schema.Attribute.DateTimeValue) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "date";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: Schema.Attribute.DateValue | (() => Schema.Attribute.DateValue) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "decimal";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: number | (() => number) | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    unique?: boolean | undefined;
+} | {
+    type: "email";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "enumeration";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    enum: string[];
+    enumName?: string | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "float";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: number | (() => number) | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    unique?: boolean | undefined;
+} | {
+    type: "integer";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: number | (() => number) | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    unique?: boolean | undefined;
+} | {
+    type: "json";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    required?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    default?: import("@strapi/types/dist/utils").JSONPrimitive | (() => import("@strapi/types/dist/utils").JSONPrimitive) | undefined;
+} | {
+    type: "password";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "morphToOne";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "morphToMany";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.CommonBidirectionalProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    inversedBy?: string | undefined;
+    mappedBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "oneToOne";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.CommonBidirectionalProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    inversedBy?: string | undefined;
+    mappedBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "oneToMany";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.CommonBidirectionalProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    inversedBy?: string | undefined;
+    mappedBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "manyToOne";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.CommonBidirectionalProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    inversedBy?: string | undefined;
+    mappedBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "manyToMany";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.XWayCommonProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "oneWay";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.XWayCommonProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "manyWay";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.MorphReferenceCommonProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    morphBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "morphOne";
-}) | (Schema.Attribute.OfType<"relation"> & Schema.Attribute.MorphReferenceCommonProperties<import("@strapi/types/dist/uid").ContentType> & Schema.Attribute.ConfigurableOption & Schema.Attribute.PrivateOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption & Schema.Attribute.RequiredOption & {
+} | {
+    type: "relation";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    target: import("@strapi/types/dist/uid").ContentType;
+    morphBy?: string | undefined;
+    configurable?: boolean | undefined;
+    private?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+    required?: boolean | undefined;
     useJoinTable?: boolean | undefined;
-} & {
     relation: "morphMany";
-}) | (Schema.Attribute.OfType<"richtext"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"string"> & Schema.Attribute.StringProperties & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.UniqueOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"text"> & Schema.Attribute.TextProperties & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.UniqueOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"time"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<Schema.Attribute.TimeValue> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.UniqueOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"timestamp"> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<Schema.Attribute.TimestampValue> & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.UniqueOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | (Schema.Attribute.OfType<"uid"> & Schema.Attribute.UIDProperties<string, Schema.Attribute.UIDOptions> & Schema.Attribute.ConfigurableOption & Schema.Attribute.DefaultOption<string> & Schema.Attribute.MinMaxLengthOption & Schema.Attribute.PrivateOption & Schema.Attribute.RequiredOption & Schema.Attribute.WritableOption & Schema.Attribute.VisibleOption) | {
+} | {
+    type: "richtext";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "string";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    regex?: RegExp | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    unique?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "text";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    regex?: RegExp | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    unique?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "time";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: Schema.Attribute.TimeValue | (() => Schema.Attribute.TimeValue) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "timestamp";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    configurable?: boolean | undefined;
+    default?: Schema.Attribute.TimestampValue | (() => Schema.Attribute.TimestampValue) | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    unique?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
+    type: "uid";
+    pluginOptions?: object | undefined;
+    searchable?: boolean | undefined;
+    column?: Partial<Schema.Attribute.Column> | undefined;
+    targetField?: string | undefined;
+    options?: Schema.Attribute.UIDOptions | undefined;
+    configurable?: boolean | undefined;
+    default?: string | (() => string) | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    private?: boolean | undefined;
+    required?: boolean | undefined;
+    writable?: boolean | undefined;
+    visible?: boolean | undefined;
+} | {
     type: string;
     relation: string;
     target: string;

package/dist/utils/transform-content-types-to-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform-content-types-to-models.d.ts","sourceRoot":"","sources":["../../src/utils/transform-content-types-to-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,yBAAyB,mBAAoB,MAAM,eAAe,WAAW,WAKzF,CAAC;AAEF,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,eAAe,WAAW,WAKlF,CAAC;AAEF,eAAO,MAAM,gCAAgC,gBAAiB,WAAW,WAKxE,CAAC;AAEF,eAAO,MAAM,iCAAiC,gBAAiB,WAAW,WAKzE,CAAC;AAEF,eAAO,MAAM,sBAAsB,gBAAiB,WAAW,WAE9D,CAAC;AAEF,eAAO,MAAM,uBAAuB,gBAAiB,MAAM,eAAe,WAAW,WAMpF,CAAC;AAIF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,iBAAiB,GAC3D,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,GAChF,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AAG5B,eAAO,MAAM,kBAAkB,SACvB,MAAM,aACD,OAAO,SAAS,CAAC,YAAY,eAC3B,sBAAsB,eACtB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBACjB,sBAAsB,eACtB,WAAW,OAazB,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBACf,sBAAsB;UACc,aAAa,GAAG,WAAW;CAI7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,iBAAW,CAAC;AAgFzC,eAAO,MAAM,6BAA6B,iBAC1B,sBAAsB,EAAE,eACzB,WAAW,KACvB,KAAK,EAkEP,CAAC"}
+{"version":3,"file":"transform-content-types-to-models.d.ts","sourceRoot":"","sources":["../../src/utils/transform-content-types-to-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,yBAAyB,mBAAoB,MAAM,eAAe,WAAW,WAKzF,CAAC;AAEF,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,eAAe,WAAW,WAKlF,CAAC;AAEF,eAAO,MAAM,gCAAgC,gBAAiB,WAAW,WAKxE,CAAC;AAEF,eAAO,MAAM,iCAAiC,gBAAiB,WAAW,WAKzE,CAAC;AAEF,eAAO,MAAM,sBAAsB,gBAAiB,WAAW,WAE9D,CAAC;AAEF,eAAO,MAAM,uBAAuB,gBAAiB,MAAM,eAAe,WAAW,WAMpF,CAAC;AAIF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,iBAAiB,GAC3D,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,GAChF,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AAG5B,eAAO,MAAM,kBAAkB,SACvB,MAAM,aACD,OAAO,SAAS,CAAC,YAAY,eAC3B,sBAAsB,eACtB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBACjB,sBAAsB,eACtB,WAAW,OAazB,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBACf,sBAAsB;UACc,aAAa,GAAG,WAAW;CAI7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,iBAAW,CAAC;AAgFzC,eAAO,MAAM,6BAA6B,iBAC1B,sBAAsB,EAAE,eACzB,WAAW,KACvB,KAAK,EAkEP,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/core",
-  "version": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
+  "version": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
   "description": "Core of Strapi",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -53,17 +53,17 @@
   },
   "dependencies": {
     "@koa/cors": "5.0.0",
-    "@koa/router": "12.0.1",
+    "@koa/router": "12.0.2",
     "@paralleldrive/cuid2": "2.2.2",
-    "@strapi/admin": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/database": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/generators": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/logger": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
+    "@strapi/admin": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/database": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/generators": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/logger": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
     "@strapi/pack-up": "5.0.0",
-    "@strapi/permissions": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/types": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/typescript-utils": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
-    "@strapi/utils": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
+    "@strapi/permissions": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/types": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/typescript-utils": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
+    "@strapi/utils": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -102,7 +102,7 @@
     "resolve.exports": "2.0.2",
     "semver": "7.5.4",
     "statuses": "2.0.1",
-    "typescript": "5.2.2",
+    "typescript": "5.3.2",
     "undici": "6.19.2",
     "yup": "0.32.9"
   },
@@ -126,13 +126,13 @@
     "@types/node": "18.19.24",
     "@types/node-schedule": "2.1.7",
     "@types/statuses": "2.0.1",
-    "eslint-config-custom": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c",
+    "eslint-config-custom": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de",
     "supertest": "6.3.3",
-    "tsconfig": "0.0.0-next.4052765aa209dd4f3d92b81baee295fc0213c04c"
+    "tsconfig": "0.0.0-next.4119cc523a8fec549bb2f1869c6e789650f7f4de"
   },
   "engines": {
-    "node": ">=18.0.0 <=20.x.x",
+    "node": ">=18.0.0 <=22.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "4052765aa209dd4f3d92b81baee295fc0213c04c"
+  "gitHead": "4119cc523a8fec549bb2f1869c6e789650f7f4de"
 }