npm - @strapi/content-type-builder - Versions diffs - 5.55.1 → 5.57.0 - Mend

@strapi/content-type-builder 5.55.1 → 5.57.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (152) hide show

package/dist/admin/src/components/Relation/RelationNaturePicker/Components.d.ts CHANGED Viewed

@@ -1,20 +1,20 @@
 import { BoxComponent, FlexComponent } from '@strapi/design-system';
 declare const Wrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
     children?: React.ReactNode;
-} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+} & import("@strapi/design-system/dist/types.js").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types.js").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
 }, never> & Partial<Pick<Omit<import("@strapi/design-system").TransientBoxProps & {
     children?: React.ReactNode;
-} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+} & import("@strapi/design-system/dist/types.js").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types.js").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
 }, never>>> & string & Omit<BoxComponent, keyof import("react").Component<any, {}, any>>;
 declare const IconWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
     children?: React.ReactNode;
-} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+} & import("@strapi/design-system/dist/types.js").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types.js").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
@@ -22,7 +22,7 @@ declare const IconWrapper: import("styled-components/dist/types").IStyledCompone
     $isSelected: boolean;
 }, never> & Partial<Pick<import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
     children?: React.ReactNode;
-} & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
+} & import("@strapi/design-system/dist/types.js").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types.js").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;

package/dist/admin/src/types.d.ts CHANGED Viewed

@@ -28,6 +28,18 @@ export type Base = {
     customField?: string;
     conditions?: AttributeConditions;
 };
+/**
+ * A single attribute rename hop, recorded in the exact order the user performed
+ * it so the server can replay it as a data-preserving migration. Because the CTB
+ * forbids duplicate field names at any instant, the recorded sequence is always
+ * collision-free (a swap is expressed through the user's own intermediate name).
+ * Only renames of fields that already exist in the database are tracked — never
+ * brand-new fields. Transient (admin only).
+ */
+export type RenameHop = {
+    oldName: string;
+    newName: string;
+};
 export type Relation = Base & {
     type: 'relation';
     relation: Schema.Attribute.RelationKind.Any;
@@ -48,9 +60,18 @@ export type Media = Base & {
     pluginOptions?: Record<string, unknown>;
 };
 export type AnyAttribute = Base & (Schema.Attribute.BigInteger | Schema.Attribute.Boolean | Schema.Attribute.Blocks | Schema.Attribute.Component<UID.Component, boolean> | Schema.Attribute.DateTime | Schema.Attribute.Date | Schema.Attribute.Decimal | Schema.Attribute.DynamicZone | Schema.Attribute.Email | Schema.Attribute.Enumeration<string[]> | Schema.Attribute.Float | Schema.Attribute.Integer | Schema.Attribute.JSON | Schema.Attribute.Password | Schema.Attribute.RichText | Schema.Attribute.String | Schema.Attribute.Text | Schema.Attribute.Time | Schema.Attribute.Timestamp | Schema.Attribute.UID | Media | Relation);
+/**
+ * Attribute names involved in rename chains the user declined to preserve data
+ * for (`prompt-after-edit` mode). A later hop touching one of these names is
+ * declined without a prompt so a chain is never partially preserved. Transient
+ * (admin only), never sent to the server.
+ */
+export type DeclinedRenameNames = string[];
 export type Component = Omit<Struct.ComponentSchema, 'attributes'> & {
     status: Status;
     attributes: Array<AnyAttribute>;
+    renames?: RenameHop[];
+    declinedRenameNames?: DeclinedRenameNames;
 };
 export type ContentType = Omit<Struct.ContentTypeSchema, 'attributes'> & {
     plugin?: string;
@@ -58,6 +79,8 @@ export type ContentType = Omit<Struct.ContentTypeSchema, 'attributes'> & {
     status: Status;
     restrictRelationsTo: Schema.Attribute.RelationKind.Any[] | null;
     attributes: Array<AnyAttribute>;
+    renames?: RenameHop[];
+    declinedRenameNames?: DeclinedRenameNames;
 };
 export type Components = Record<string, Component>;
 export type ContentTypes = Record<string, ContentType>;

package/dist/admin/translations/en.json.js CHANGED Viewed

@@ -153,6 +153,9 @@ var en = {
     "form.attribute.condition.enum-change-warning-end": " will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning": "The following fields have conditions that depend on this field: {fieldNames}. Renaming it will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning-end": ". Renaming it will break these conditions. Do you want to proceed?",
+    "form.attribute.rename-type-change-warning.title": "Existing data will be lost",
+    "form.attribute.rename-type-change-warning.body": "You are renaming {oldName} to {newName} and changing it from {oldType} to {newType}. Strapi cannot preserve the existing data of this field when both change at once. The field will be recreated empty when you save.",
+    "form.attribute.rename-type-change-warning.confirm": "Continue",
     "form.button.add-components-to-dynamiczone": "Add components to the zone",
     "form.button.add-field": "Add another field",
     "form.button.add-first-field-to-created-component": "Add first field to the component",
@@ -173,6 +176,15 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "migration.confirmation.title": "Preserve data for renamed fields?",
+    "migration.confirmation.description": "You renamed the fields below. Strapi can generate a migration to preserve existing data by renaming the underlying database columns. Untick a rename to let those fields start empty instead.",
+    "migration.confirmation.field.in": "in {typeName}",
+    "migration.confirmation.field.preserve": "Preserve data of {names} in {typeName}",
+    "migration.confirmation.field.via": "via {names}",
+    "migration.confirmation.field.swap": "Fields swapped back to their original names; data still moves.",
+    "migration.confirmation.cancel": "Cancel",
+    "migration.confirmation.decline": "Don't preserve data",
+    "migration.confirmation.confirm": "Preserve data",
     "nav.action.new-collection-type": "New Collection-Type",
     "nav.action.new-folder": "New folder",
     "nav.action.new-single-type": "New Single-Type",

package/dist/admin/translations/en.json.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1	+ {"version":3,"file":"en.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/admin/translations/en.json.mjs CHANGED Viewed

@@ -149,6 +149,9 @@ var en = {
     "form.attribute.condition.enum-change-warning-end": " will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning": "The following fields have conditions that depend on this field: {fieldNames}. Renaming it will break these conditions. Do you want to proceed?",
     "form.attribute.condition.field-change-warning-end": ". Renaming it will break these conditions. Do you want to proceed?",
+    "form.attribute.rename-type-change-warning.title": "Existing data will be lost",
+    "form.attribute.rename-type-change-warning.body": "You are renaming {oldName} to {newName} and changing it from {oldType} to {newType}. Strapi cannot preserve the existing data of this field when both change at once. The field will be recreated empty when you save.",
+    "form.attribute.rename-type-change-warning.confirm": "Continue",
     "form.button.add-components-to-dynamiczone": "Add components to the zone",
     "form.button.add-field": "Add another field",
     "form.button.add-first-field-to-created-component": "Add first field to the component",
@@ -169,6 +172,15 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "migration.confirmation.title": "Preserve data for renamed fields?",
+    "migration.confirmation.description": "You renamed the fields below. Strapi can generate a migration to preserve existing data by renaming the underlying database columns. Untick a rename to let those fields start empty instead.",
+    "migration.confirmation.field.in": "in {typeName}",
+    "migration.confirmation.field.preserve": "Preserve data of {names} in {typeName}",
+    "migration.confirmation.field.via": "via {names}",
+    "migration.confirmation.field.swap": "Fields swapped back to their original names; data still moves.",
+    "migration.confirmation.cancel": "Cancel",
+    "migration.confirmation.decline": "Don't preserve data",
+    "migration.confirmation.confirm": "Preserve data",
     "nav.action.new-collection-type": "New Collection-Type",
     "nav.action.new-folder": "New folder",
     "nav.action.new-single-type": "New Single-Type",

package/dist/admin/translations/en.json.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1	+ {"version":3,"file":"en.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/server/config.js CHANGED Viewed

@@ -1,9 +1,30 @@
 'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+const ATTRIBUTE_RENAME_MIGRATION_MODES = [
+    'always',
+    'never',
+    'prompt-after-edit',
+    'prompt-before-save'
+];
 var config = {
-    default: {},
-    validator () {}
+    default: {
+        renameMigrations: {
+            attributes: 'prompt-before-save'
+        }
+    },
+    validator (config) {
+        const renameMigrations = config.renameMigrations;
+        if (renameMigrations === undefined) {
+            return;
+        }
+        if (renameMigrations.attributes !== undefined && !ATTRIBUTE_RENAME_MIGRATION_MODES.includes(renameMigrations.attributes)) {
+            throw new Error(`[content-type-builder] 'renameMigrations.attributes' must be one of: ${ATTRIBUTE_RENAME_MIGRATION_MODES.join(', ')}. Received: ${JSON.stringify(renameMigrations.attributes)}`);
+        }
+    }
 };
-module.exports = config;
+exports.ATTRIBUTE_RENAME_MIGRATION_MODES = ATTRIBUTE_RENAME_MIGRATION_MODES;
+exports.default = config;
 //# sourceMappingURL=config.js.map

package/dist/server/config.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"config.js","sources":["../../server/src/config.ts"],"sourcesContent":["export default {\n default: {},\n validator() {},\n};\n"],"names":["default","validator"],"mappings":";;~~AAAA~~,aAAe;~~AACbA~~,~~IAAAA,~~OAAAA,EAAS,~~EAAC~~;~~IACVC~~,SAAAA,CAAAA,~~GAAAA~~,~~CAAa~~;~~AACf~~,CAAA~~;;;;~~"}
1	+ {"version":3,"file":"config.js","sources":["../../server/src/config.ts"],"sourcesContent":["export const ATTRIBUTE_RENAME_MIGRATION_MODES = [\n 'always',\n 'never',\n 'prompt-after-edit',\n 'prompt-before-save',\n] as const;\n\nexport type AttributeRenameMigrationMode = (typeof ATTRIBUTE_RENAME_MIGRATION_MODES)[number];\n\nexport interface RenameMigrationsConfig {\n /*\n Attribute rename behavior. A contentTypes setting can be added alongside\n * this later without changing the public configuration shape.\n */\n attributes: AttributeRenameMigrationMode;\n}\n\nexport interface ContentTypeBuilderConfig {\n renameMigrations: RenameMigrationsConfig;\n}\n\ntype ContentTypeBuilderUserConfig = {\n renameMigrations?: {\n attributes?: AttributeRenameMigrationMode;\n };\n};\n\nexport default {\n default: {\n renameMigrations: {\n attributes: 'prompt-before-save',\n },\n } satisfies ContentTypeBuilderConfig,\n validator(config: ContentTypeBuilderUserConfig) {\n const renameMigrations = config.renameMigrations;\n if (renameMigrations === undefined) {\n return;\n }\n\n if (\n renameMigrations.attributes !== undefined &&\n !ATTRIBUTE_RENAME_MIGRATION_MODES.includes(renameMigrations.attributes)\n ) {\n throw new Error(\n `[content-type-builder] 'renameMigrations.attributes' must be one of: ${ATTRIBUTE_RENAME_MIGRATION_MODES.join(\n ', '\n )}. Received: ${JSON.stringify(renameMigrations.attributes)}`\n );\n }\n },\n};\n"],"names":["ATTRIBUTE_RENAME_MIGRATION_MODES","default","renameMigrations","attributes","validator","config","undefined","includes","Error","join","JSON","stringify"],"mappings":";;;;MAAaA,gCAAAA,GAAmC;AAC9C,IAAA,QAAA;AACA,IAAA,OAAA;AACA,IAAA,mBAAA;AACA,IAAA;;AAuBF,aAAe;IACbC,OAAAA,EAAS;QACPC,gBAAAA,EAAkB;YAChBC,UAAAA,EAAY;AACd;AACF,KAAA;AACAC,IAAAA,SAAAA,CAAAA,CAAUC,MAAoC,EAAA;QAC5C,MAAMH,gBAAAA,GAAmBG,OAAOH,gBAAgB;AAChD,QAAA,IAAIA,qBAAqBI,SAAAA,EAAW;AAClC,YAAA;AACF,QAAA;QAEA,IACEJ,gBAAAA,CAAiBC,UAAU,KAAKG,SAAAA,IAChC,CAACN,iCAAiCO,QAAQ,CAACL,gBAAAA,CAAiBC,UAAU,CAAA,EACtE;AACA,YAAA,MAAM,IAAIK,KAAAA,CACR,CAAC,qEAAqE,EAAER,iCAAiCS,IAAI,CAC3G,IAAA,CAAA,CACA,YAAY,EAAEC,IAAAA,CAAKC,SAAS,CAACT,gBAAAA,CAAiBC,UAAU,CAAA,CAAA,CAAG,CAAA;AAEjE,QAAA;AACF,IAAA;AACF,CAAA;;;;;"}

package/dist/server/config.mjs CHANGED Viewed

@@ -1,7 +1,25 @@
+const ATTRIBUTE_RENAME_MIGRATION_MODES = [
+    'always',
+    'never',
+    'prompt-after-edit',
+    'prompt-before-save'
+];
 var config = {
-    default: {},
-    validator () {}
+    default: {
+        renameMigrations: {
+            attributes: 'prompt-before-save'
+        }
+    },
+    validator (config) {
+        const renameMigrations = config.renameMigrations;
+        if (renameMigrations === undefined) {
+            return;
+        }
+        if (renameMigrations.attributes !== undefined && !ATTRIBUTE_RENAME_MIGRATION_MODES.includes(renameMigrations.attributes)) {
+            throw new Error(`[content-type-builder] 'renameMigrations.attributes' must be one of: ${ATTRIBUTE_RENAME_MIGRATION_MODES.join(', ')}. Received: ${JSON.stringify(renameMigrations.attributes)}`);
+        }
+    }
 };
-export { config as default };
+export { ATTRIBUTE_RENAME_MIGRATION_MODES, config as default };
 //# sourceMappingURL=config.mjs.map

package/dist/server/config.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"config.mjs","sources":["../../server/src/config.ts"],"sourcesContent":["export default {\n default: {},\n validator() {},\n};\n"],"names":["default","validator"],"mappings":"~~AAAA~~,aAAe;~~AACbA~~,~~IAAAA,~~OAAAA,EAAS,~~EAAC~~;~~IACVC~~,SAAAA,CAAAA,~~GAAAA~~,~~CAAa~~;~~AACf~~,CAAA;;;;"}
1	+ {"version":3,"file":"config.mjs","sources":["../../server/src/config.ts"],"sourcesContent":["export const ATTRIBUTE_RENAME_MIGRATION_MODES = [\n 'always',\n 'never',\n 'prompt-after-edit',\n 'prompt-before-save',\n] as const;\n\nexport type AttributeRenameMigrationMode = (typeof ATTRIBUTE_RENAME_MIGRATION_MODES)[number];\n\nexport interface RenameMigrationsConfig {\n /*\n Attribute rename behavior. A contentTypes setting can be added alongside\n * this later without changing the public configuration shape.\n */\n attributes: AttributeRenameMigrationMode;\n}\n\nexport interface ContentTypeBuilderConfig {\n renameMigrations: RenameMigrationsConfig;\n}\n\ntype ContentTypeBuilderUserConfig = {\n renameMigrations?: {\n attributes?: AttributeRenameMigrationMode;\n };\n};\n\nexport default {\n default: {\n renameMigrations: {\n attributes: 'prompt-before-save',\n },\n } satisfies ContentTypeBuilderConfig,\n validator(config: ContentTypeBuilderUserConfig) {\n const renameMigrations = config.renameMigrations;\n if (renameMigrations === undefined) {\n return;\n }\n\n if (\n renameMigrations.attributes !== undefined &&\n !ATTRIBUTE_RENAME_MIGRATION_MODES.includes(renameMigrations.attributes)\n ) {\n throw new Error(\n `[content-type-builder] 'renameMigrations.attributes' must be one of: ${ATTRIBUTE_RENAME_MIGRATION_MODES.join(\n ', '\n )}. Received: ${JSON.stringify(renameMigrations.attributes)}`\n );\n }\n },\n};\n"],"names":["ATTRIBUTE_RENAME_MIGRATION_MODES","default","renameMigrations","attributes","validator","config","undefined","includes","Error","join","JSON","stringify"],"mappings":"MAAaA,gCAAAA,GAAmC;AAC9C,IAAA,QAAA;AACA,IAAA,OAAA;AACA,IAAA,mBAAA;AACA,IAAA;;AAuBF,aAAe;IACbC,OAAAA,EAAS;QACPC,gBAAAA,EAAkB;YAChBC,UAAAA,EAAY;AACd;AACF,KAAA;AACAC,IAAAA,SAAAA,CAAAA,CAAUC,MAAoC,EAAA;QAC5C,MAAMH,gBAAAA,GAAmBG,OAAOH,gBAAgB;AAChD,QAAA,IAAIA,qBAAqBI,SAAAA,EAAW;AAClC,YAAA;AACF,QAAA;QAEA,IACEJ,gBAAAA,CAAiBC,UAAU,KAAKG,SAAAA,IAChC,CAACN,iCAAiCO,QAAQ,CAACL,gBAAAA,CAAiBC,UAAU,CAAA,EACtE;AACA,YAAA,MAAM,IAAIK,KAAAA,CACR,CAAC,qEAAqE,EAAER,iCAAiCS,IAAI,CAC3G,IAAA,CAAA,CACA,YAAY,EAAEC,IAAAA,CAAKC,SAAS,CAACT,gBAAAA,CAAiBC,UAAU,CAAA,CAAA,CAAG,CAAA;AAEjE,QAAA;AACF,IAAA;AACF,CAAA;;;;"}

package/dist/server/controllers/schema.js CHANGED Viewed

@@ -1,6 +1,6 @@
 'use strict';
-var fp = require('lodash/fp');
+var _ = require('lodash');
 var index = require('../utils/index.js');
 var schema$1 = require('./validation/schema.js');
@@ -21,7 +21,7 @@ var schema = (()=>{
             }
             try {
                 const { data } = await schema$1.validateUpdateSchema(ctx.request.body);
-                if (fp.isEmpty(data.components) && fp.isEmpty(data.contentTypes) && fp.isEmpty(data.contentStructure)) {
+                if (_.isEmpty(data.components) && _.isEmpty(data.contentTypes) && _.isEmpty(data.contentStructure)) {
                     ctx.body = {};
                     return;
                 }

package/dist/server/controllers/schema.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schema.js","sources":["../../../server/src/controllers/schema.ts"],"sourcesContent":["import type { Context } from 'koa';\nimport { isEmpty } from 'lodash~~/fp~~';\n\nimport { getService } from '../utils';\nimport { validateUpdateSchema } from './validation/schema';\n\nexport default () => {\n const internals = {\n isUpdating: false,\n };\n\n return {\n async getSchema(ctx: Context) {\n const schema = await getService('schema').getSchema();\n\n ctx.send({ data: schema });\n },\n\n async updateSchema(ctx: Context) {\n if (internals.isUpdating === true) {\n return ctx.conflict('Schema update is already in progress.');\n }\n\n try {\n const { data } = await validateUpdateSchema(ctx.request.body);\n\n if (\n isEmpty(data.components) &&\n isEmpty(data.contentTypes) &&\n isEmpty(data.contentStructure)\n ) {\n ctx.body = {};\n return;\n }\n\n internals.isUpdating = true;\n strapi.reload.isWatching = false;\n\n await getService('schema').updateSchema(data);\n\n // NOTE: we do not set isUpdating to false here.\n // We want to wait for the server to restart to get the isUpdate = false only\n setImmediate(() => {\n strapi.reload();\n });\n\n ctx.body = {};\n } catch (error) {\n internals.isUpdating = false;\n const errorMessage = error instanceof Error ? error.message : String(error);\n return ctx.send({ error: errorMessage }, 400);\n }\n },\n\n async getUpdateSchemaStatus(ctx: Context) {\n ctx.send({ data: { isUpdating: internals.isUpdating } });\n },\n };\n};\n"],"names":["internals","isUpdating","getSchema","ctx","schema","getService","send","data","updateSchema","conflict","validateUpdateSchema","request","body","isEmpty","components","contentTypes","contentStructure","strapi","reload","isWatching","setImmediate","error","errorMessage","Error","message","String","getUpdateSchemaStatus"],"mappings":";;;;;;AAMA,aAAe,CAAA,IAAA;AACb,IAAA,MAAMA,SAAAA,GAAY;QAChBC,UAAAA,EAAY;AACd,KAAA;IAEA,OAAO;AACL,QAAA,MAAMC,WAAUC,GAAY,EAAA;AAC1B,YAAA,MAAMC,MAAAA,GAAS,MAAMC,gBAAAA,CAAW,QAAA,CAAA,CAAUH,SAAS,EAAA;AAEnDC,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAMH;AAAO,aAAA,CAAA;AAC1B,QAAA,CAAA;AAEA,QAAA,MAAMI,cAAaL,GAAY,EAAA;YAC7B,IAAIH,SAAAA,CAAUC,UAAU,KAAK,IAAA,EAAM;gBACjC,OAAOE,GAAAA,CAAIM,QAAQ,CAAC,uCAAA,CAAA;AACtB,YAAA;YAEA,IAAI;gBACF,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAMG,6BAAAA,CAAqBP,GAAAA,CAAIQ,OAAO,CAACC,IAAI,CAAA;gBAE5D,IACEC,~~UAAAA~~,CAAQN,IAAAA,CAAKO,UAAU,CAAA,IACvBD,~~UAAAA~~,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,IACzBF,~~UAAAA~~,CAAQN,IAAAA,CAAKS,gBAAgB,CAAA,EAC7B;oBACAb,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBgB,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMd,gBAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCa,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAf,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOS,KAAAA,EAAO;AACdrB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMqB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOlB,GAAAA,CAAIG,IAAI,CAAC;oBAAEe,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBvB,GAAY,EAAA;AACtCA,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAM;AAAEN,oBAAAA,UAAAA,EAAYD,UAAUC;AAAW;AAAE,aAAA,CAAA;AACxD,QAAA;AACF,KAAA;AACF,CAAA;;;;"}
1	+ {"version":3,"file":"schema.js","sources":["../../../server/src/controllers/schema.ts"],"sourcesContent":["import type { Context } from 'koa';\nimport { isEmpty } from 'lodash';\n\nimport { getService } from '../utils';\nimport { validateUpdateSchema } from './validation/schema';\n\nexport default () => {\n const internals = {\n isUpdating: false,\n };\n\n return {\n async getSchema(ctx: Context) {\n const schema = await getService('schema').getSchema();\n\n ctx.send({ data: schema });\n },\n\n async updateSchema(ctx: Context) {\n if (internals.isUpdating === true) {\n return ctx.conflict('Schema update is already in progress.');\n }\n\n try {\n const { data } = await validateUpdateSchema(ctx.request.body);\n\n if (\n isEmpty(data.components) &&\n isEmpty(data.contentTypes) &&\n isEmpty(data.contentStructure)\n ) {\n ctx.body = {};\n return;\n }\n\n internals.isUpdating = true;\n strapi.reload.isWatching = false;\n\n await getService('schema').updateSchema(data);\n\n // NOTE: we do not set isUpdating to false here.\n // We want to wait for the server to restart to get the isUpdate = false only\n setImmediate(() => {\n strapi.reload();\n });\n\n ctx.body = {};\n } catch (error) {\n internals.isUpdating = false;\n const errorMessage = error instanceof Error ? error.message : String(error);\n return ctx.send({ error: errorMessage }, 400);\n }\n },\n\n async getUpdateSchemaStatus(ctx: Context) {\n ctx.send({ data: { isUpdating: internals.isUpdating } });\n },\n };\n};\n"],"names":["internals","isUpdating","getSchema","ctx","schema","getService","send","data","updateSchema","conflict","validateUpdateSchema","request","body","isEmpty","components","contentTypes","contentStructure","strapi","reload","isWatching","setImmediate","error","errorMessage","Error","message","String","getUpdateSchemaStatus"],"mappings":";;;;;;AAMA,aAAe,CAAA,IAAA;AACb,IAAA,MAAMA,SAAAA,GAAY;QAChBC,UAAAA,EAAY;AACd,KAAA;IAEA,OAAO;AACL,QAAA,MAAMC,WAAUC,GAAY,EAAA;AAC1B,YAAA,MAAMC,MAAAA,GAAS,MAAMC,gBAAAA,CAAW,QAAA,CAAA,CAAUH,SAAS,EAAA;AAEnDC,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAMH;AAAO,aAAA,CAAA;AAC1B,QAAA,CAAA;AAEA,QAAA,MAAMI,cAAaL,GAAY,EAAA;YAC7B,IAAIH,SAAAA,CAAUC,UAAU,KAAK,IAAA,EAAM;gBACjC,OAAOE,GAAAA,CAAIM,QAAQ,CAAC,uCAAA,CAAA;AACtB,YAAA;YAEA,IAAI;gBACF,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAMG,6BAAAA,CAAqBP,GAAAA,CAAIQ,OAAO,CAACC,IAAI,CAAA;gBAE5D,IACEC,SAAAA,CAAQN,IAAAA,CAAKO,UAAU,CAAA,IACvBD,SAAAA,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,IACzBF,SAAAA,CAAQN,IAAAA,CAAKS,gBAAgB,CAAA,EAC7B;oBACAb,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBgB,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMd,gBAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCa,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAf,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOS,KAAAA,EAAO;AACdrB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMqB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOlB,GAAAA,CAAIG,IAAI,CAAC;oBAAEe,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBvB,GAAY,EAAA;AACtCA,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAM;AAAEN,oBAAAA,UAAAA,EAAYD,UAAUC;AAAW;AAAE,aAAA,CAAA;AACxD,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/controllers/schema.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-import { isEmpty } from 'lodash/fp';
+import { isEmpty } from 'lodash';
 import { getService } from '../utils/index.mjs';
 import { validateUpdateSchema } from './validation/schema.mjs';

package/dist/server/controllers/schema.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schema.mjs","sources":["../../../server/src/controllers/schema.ts"],"sourcesContent":["import type { Context } from 'koa';\nimport { isEmpty } from 'lodash~~/fp~~';\n\nimport { getService } from '../utils';\nimport { validateUpdateSchema } from './validation/schema';\n\nexport default () => {\n const internals = {\n isUpdating: false,\n };\n\n return {\n async getSchema(ctx: Context) {\n const schema = await getService('schema').getSchema();\n\n ctx.send({ data: schema });\n },\n\n async updateSchema(ctx: Context) {\n if (internals.isUpdating === true) {\n return ctx.conflict('Schema update is already in progress.');\n }\n\n try {\n const { data } = await validateUpdateSchema(ctx.request.body);\n\n if (\n isEmpty(data.components) &&\n isEmpty(data.contentTypes) &&\n isEmpty(data.contentStructure)\n ) {\n ctx.body = {};\n return;\n }\n\n internals.isUpdating = true;\n strapi.reload.isWatching = false;\n\n await getService('schema').updateSchema(data);\n\n // NOTE: we do not set isUpdating to false here.\n // We want to wait for the server to restart to get the isUpdate = false only\n setImmediate(() => {\n strapi.reload();\n });\n\n ctx.body = {};\n } catch (error) {\n internals.isUpdating = false;\n const errorMessage = error instanceof Error ? error.message : String(error);\n return ctx.send({ error: errorMessage }, 400);\n }\n },\n\n async getUpdateSchemaStatus(ctx: Context) {\n ctx.send({ data: { isUpdating: internals.isUpdating } });\n },\n };\n};\n"],"names":["internals","isUpdating","getSchema","ctx","schema","getService","send","data","updateSchema","conflict","validateUpdateSchema","request","body","isEmpty","components","contentTypes","contentStructure","strapi","reload","isWatching","setImmediate","error","errorMessage","Error","message","String","getUpdateSchemaStatus"],"mappings":";;;;AAMA,aAAe,CAAA,IAAA;AACb,IAAA,MAAMA,SAAAA,GAAY;QAChBC,UAAAA,EAAY;AACd,KAAA;IAEA,OAAO;AACL,QAAA,MAAMC,WAAUC,GAAY,EAAA;AAC1B,YAAA,MAAMC,MAAAA,GAAS,MAAMC,UAAAA,CAAW,QAAA,CAAA,CAAUH,SAAS,EAAA;AAEnDC,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAMH;AAAO,aAAA,CAAA;AAC1B,QAAA,CAAA;AAEA,QAAA,MAAMI,cAAaL,GAAY,EAAA;YAC7B,IAAIH,SAAAA,CAAUC,UAAU,KAAK,IAAA,EAAM;gBACjC,OAAOE,GAAAA,CAAIM,QAAQ,CAAC,uCAAA,CAAA;AACtB,YAAA;YAEA,IAAI;gBACF,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAMG,oBAAAA,CAAqBP,GAAAA,CAAIQ,OAAO,CAACC,IAAI,CAAA;gBAE5D,IACEC,OAAAA,CAAQN,IAAAA,CAAKO,UAAU,CAAA,IACvBD,OAAAA,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,IACzBF,OAAAA,CAAQN,IAAAA,CAAKS,gBAAgB,CAAA,EAC7B;oBACAb,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBgB,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMd,UAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCa,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAf,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOS,KAAAA,EAAO;AACdrB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMqB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOlB,GAAAA,CAAIG,IAAI,CAAC;oBAAEe,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBvB,GAAY,EAAA;AACtCA,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAM;AAAEN,oBAAAA,UAAAA,EAAYD,UAAUC;AAAW;AAAE,aAAA,CAAA;AACxD,QAAA;AACF,KAAA;AACF,CAAA;;;;"}
1	+ {"version":3,"file":"schema.mjs","sources":["../../../server/src/controllers/schema.ts"],"sourcesContent":["import type { Context } from 'koa';\nimport { isEmpty } from 'lodash';\n\nimport { getService } from '../utils';\nimport { validateUpdateSchema } from './validation/schema';\n\nexport default () => {\n const internals = {\n isUpdating: false,\n };\n\n return {\n async getSchema(ctx: Context) {\n const schema = await getService('schema').getSchema();\n\n ctx.send({ data: schema });\n },\n\n async updateSchema(ctx: Context) {\n if (internals.isUpdating === true) {\n return ctx.conflict('Schema update is already in progress.');\n }\n\n try {\n const { data } = await validateUpdateSchema(ctx.request.body);\n\n if (\n isEmpty(data.components) &&\n isEmpty(data.contentTypes) &&\n isEmpty(data.contentStructure)\n ) {\n ctx.body = {};\n return;\n }\n\n internals.isUpdating = true;\n strapi.reload.isWatching = false;\n\n await getService('schema').updateSchema(data);\n\n // NOTE: we do not set isUpdating to false here.\n // We want to wait for the server to restart to get the isUpdate = false only\n setImmediate(() => {\n strapi.reload();\n });\n\n ctx.body = {};\n } catch (error) {\n internals.isUpdating = false;\n const errorMessage = error instanceof Error ? error.message : String(error);\n return ctx.send({ error: errorMessage }, 400);\n }\n },\n\n async getUpdateSchemaStatus(ctx: Context) {\n ctx.send({ data: { isUpdating: internals.isUpdating } });\n },\n };\n};\n"],"names":["internals","isUpdating","getSchema","ctx","schema","getService","send","data","updateSchema","conflict","validateUpdateSchema","request","body","isEmpty","components","contentTypes","contentStructure","strapi","reload","isWatching","setImmediate","error","errorMessage","Error","message","String","getUpdateSchemaStatus"],"mappings":";;;;AAMA,aAAe,CAAA,IAAA;AACb,IAAA,MAAMA,SAAAA,GAAY;QAChBC,UAAAA,EAAY;AACd,KAAA;IAEA,OAAO;AACL,QAAA,MAAMC,WAAUC,GAAY,EAAA;AAC1B,YAAA,MAAMC,MAAAA,GAAS,MAAMC,UAAAA,CAAW,QAAA,CAAA,CAAUH,SAAS,EAAA;AAEnDC,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAMH;AAAO,aAAA,CAAA;AAC1B,QAAA,CAAA;AAEA,QAAA,MAAMI,cAAaL,GAAY,EAAA;YAC7B,IAAIH,SAAAA,CAAUC,UAAU,KAAK,IAAA,EAAM;gBACjC,OAAOE,GAAAA,CAAIM,QAAQ,CAAC,uCAAA,CAAA;AACtB,YAAA;YAEA,IAAI;gBACF,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAMG,oBAAAA,CAAqBP,GAAAA,CAAIQ,OAAO,CAACC,IAAI,CAAA;gBAE5D,IACEC,OAAAA,CAAQN,IAAAA,CAAKO,UAAU,CAAA,IACvBD,OAAAA,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,IACzBF,OAAAA,CAAQN,IAAAA,CAAKS,gBAAgB,CAAA,EAC7B;oBACAb,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBgB,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMd,UAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCa,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAf,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOS,KAAAA,EAAO;AACdrB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMqB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOlB,GAAAA,CAAIG,IAAI,CAAC;oBAAEe,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBvB,GAAY,EAAA;AACtCA,YAAAA,GAAAA,CAAIG,IAAI,CAAC;gBAAEC,IAAAA,EAAM;AAAEN,oBAAAA,UAAAA,EAAYD,UAAUC;AAAW;AAAE,aAAA,CAAA;AACxD,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/controllers/validation/content-type.js CHANGED Viewed

@@ -1,6 +1,6 @@
 'use strict';
-var fp = require('lodash/fp');
+var _ = require('lodash');
 var utils = require('@strapi/utils');
 var index = require('../../utils/index.js');
 var constants = require('../../services/constants.js');
@@ -8,7 +8,6 @@ var modelSchema = require('./model-schema.js');
 var dataTransform = require('./data-transform.js');
 var component = require('./component.js');
-/* eslint-disable no-template-curly-in-string */ // yup templates need to be in this format
 /**
  * Allowed relation per type kind
  */ const VALID_RELATIONS = {
@@ -43,7 +42,7 @@ var component = require('./component.js');
 /**
  * Returns a yup schema to validate a content type payload
  */ const createContentTypeSchema = (data, { isEdition = false } = {})=>{
-    const kind = fp.getOr(constants.typeKinds.COLLECTION_TYPE, 'contentType.kind', data);
+    const kind = _.get(data, 'contentType.kind', constants.typeKinds.COLLECTION_TYPE);
     const contentTypeSchema = modelSchema.createSchema(VALID_TYPES, VALID_RELATIONS[kind] || [], {
         modelType: constants.modelTypes.CONTENT_TYPE
     }).shape({
@@ -71,13 +70,13 @@ var component = require('./component.js');
 /**
  * Validator for content type edition
  */ const validateUpdateContentTypeInput = (data)=>{
-    if (fp.has('contentType', data)) {
+    if (_.has(data, 'contentType')) {
         dataTransform.removeEmptyDefaults(data.contentType);
         dataTransform.removeDeletedUIDTargetFields(data.contentType);
     }
-    if (fp.has('components', data) && Array.isArray(data.components)) {
+    if (_.has(data, 'components') && Array.isArray(data.components)) {
         data.components.forEach((comp)=>{
-            if (fp.has('uid', comp)) {
+            if (_.has(comp, 'uid')) {
                 dataTransform.removeEmptyDefaults(comp);
             }
         });
@@ -100,13 +99,12 @@ const forbiddenContentTypeNameValidator = ()=>{
     };
 };
 const nameIsAvailable = (isEdition)=>{
-    // TODO TS: if strapi.contentTypes (ie, ContentTypes) works as an ArrayLike and is used like this, we may want to ensure it is typed so that it can be without using as
-    const usedNames = fp.flatMap((ct)=>{
+    const usedNames = Object.values(strapi.contentTypes).flatMap((ct)=>{
         return [
             ct.info?.singularName,
             ct.info?.pluralName
         ];
-    })(strapi.contentTypes);
+    });
     return {
         name: 'nameAlreadyUsed',
         message: 'contentType: name `${value}` is already being used by another content type.',
@@ -118,7 +116,7 @@ const nameIsAvailable = (isEdition)=>{
                 return true;
             }
             // compare snake case to check the actual column names that will be used in the database
-            return usedNames.every((usedName)=>fp.snakeCase(usedName) !== fp.snakeCase(value));
+            return usedNames.every((usedName)=>_.snakeCase(usedName) !== _.snakeCase(value));
         }
     };
 };
@@ -135,7 +133,7 @@ const nameIsNotExistingCollectionName = (isEdition)=>{
                 return true;
             }
             // compare snake case to check the actual column names that will be used in the database
-            return usedNames.every((usedName)=>fp.snakeCase(usedName) !== fp.snakeCase(value));
+            return usedNames.every((usedName)=>_.snakeCase(usedName) !== _.snakeCase(value));
         }
     };
 };

package/dist/server/controllers/validation/content-type.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"content-type.js","sources":["../../../../server/src/controllers/validation/content-type.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string / // yup templates need to be in this format\n\nimport { flatMap, getOr, has, snakeCase } from 'lodash/fp';\nimport { yup, validateYupSchema } from '@strapi/utils';\n\nimport type { Struct, Internal, UID } from '@strapi/types';\n\nimport { getService } from '../../utils';\nimport { modelTypes, DEFAULT_TYPES, typeKinds } from '../../services/constants';\nimport { createSchema } from './model-schema';\nimport { removeEmptyDefaults, removeDeletedUIDTargetFields } from './data-transform';\nimport { nestedComponentSchema } from './component';\n\n// Input flattens some fields of the \"info\" into the root type\nexport type CreateContentTypeInput = {\n uid?: UID.ContentType;\n contentType?: Partial<Struct.ContentTypeSchema> & Partial<Struct.ContentTypeSchemaInfo>;\n components?: Array<\n Partial<Struct.ComponentSchema> &\n Partial<Struct.SchemaInfo> & { tmpUID?: Internal.UID.Component }\n >;\n singularName: Struct.ContentTypeSchemaInfo['singularName'];\n attributes: Struct.SchemaAttributes & Record<string, any>;\n kind: Struct.ContentTypeKind;\n collectionName?: Struct.CollectionTypeSchema['collectionName'];\n pluralName: Struct.ContentTypeSchemaInfo['pluralName'];\n displayName: Struct.ContentTypeSchemaInfo['displayName'];\n description?: Struct.ContentTypeSchemaInfo['description'];\n options?: Struct.SchemaOptions;\n draftAndPublish?: Struct.SchemaOptions['draftAndPublish'];\n pluginOptions?: Struct.ContentTypeSchema['pluginOptions'];\n config?: object;\n plugin?: string;\n};\n\n/\n Allowed relation per type kind\n /\nconst VALID_RELATIONS = {\n [typeKinds.SINGLE_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n [typeKinds.COLLECTION_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'manyToOne',\n 'manyToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n} as const;\n\n/\n Allowed types\n /\nconst VALID_TYPES = [...DEFAULT_TYPES, 'uid', 'component', 'dynamiczone', 'customField'];\n\n/\n Returns a yup schema to validate a content type payload\n /\nconst createContentTypeSchema = (data: CreateContentTypeInput, { isEdition = false } = {}) => {\n const kind: keyof typeof VALID_RELATIONS = getOr(\n typeKinds.COLLECTION_TYPE,\n 'contentType.kind',\n data\n );\n\n const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] \|\| [], {\n modelType: modelTypes.CONTENT_TYPE,\n })\n .shape({\n displayName: yup.string().min(1).required(),\n singularName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n pluralName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(nameIsNotExistingCollectionName(isEdition)) // TODO: v5: require singularName to not match a collection name\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n })\n .test(\n 'singularName-not-equal-pluralName',\n '${path}: singularName and pluralName should be different',\n (value) => value.singularName !== value.pluralName\n );\n\n return yup\n .object({\n // FIXME .noUnknown(false) will strip off the unwanted properties without throwing an error\n // Why not having .noUnknown() ? Because we want to be able to add options relatable to EE features\n // without having any reference to them in CE.\n // Why not handle an \"options\" object in the content-type ? The admin panel needs lots of rework\n // to be able to send this options object instead of top-level attributes.\n // @nathan-pichon 20/02/2023\n contentType: contentTypeSchema.required().noUnknown(false),\n components: nestedComponentSchema,\n })\n .noUnknown();\n};\n\n/\n Validator for content type creation\n /\nexport const validateContentTypeInput = (data: CreateContentTypeInput) => {\n return validateYupSchema(createContentTypeSchema(data))(data);\n};\n\n/\n Validator for content type edition\n /\nexport const validateUpdateContentTypeInput = (data: CreateContentTypeInput) => {\n if (has('contentType', data)) {\n removeEmptyDefaults(data.contentType);\n removeDeletedUIDTargetFields(data.contentType as Struct.ContentTypeSchema);\n }\n\n if (has('components', data) && Array.isArray(data.components)) {\n data.components.forEach((comp) => {\n if (has('uid', comp)) {\n removeEmptyDefaults(comp as Struct.ComponentSchema);\n }\n });\n }\n\n return validateYupSchema(createContentTypeSchema(data, { isEdition: true }))(data);\n};\n\nconst forbiddenContentTypeNameValidator = () => {\n const reservedNames = getService('builder').getReservedNames().models;\n\n return {\n name: 'forbiddenContentTypeName',\n message: `Content Type name cannot be one of ${reservedNames.join(', ')}`,\n test(value: unknown) {\n if (typeof value !== 'string') {\n return true;\n }\n\n return !getService('builder').isReservedModelName(value);\n },\n };\n};\n\nconst nameIsAvailable = (isEdition: boolean) => {\n // TODO TS: if strapi.contentTypes (ie, ContentTypes) works as an ArrayLike and is used like this, we may want to ensure it is typed so that it can be without using as\n const usedNames = flatMap((ct: Struct.ContentTypeSchema) => {\n return [ct.info?.singularName, ct.info?.pluralName];\n })(strapi.contentTypes as any);\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\nconst nameIsNotExistingCollectionName = (isEdition: boolean) => {\n const usedNames = Object.keys(strapi.contentTypes).map(\n (key) => strapi.contentTypes[key as Internal.UID.ContentType].collectionName\n ) as string[];\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\n/\n Validates type kind\n */\nconst kindSchema = yup.string().oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE]);\n\nexport const validateKind = validateYupSchema(kindSchema);\n"],"names":["VALID_RELATIONS","typeKinds","SINGLE_TYPE","COLLECTION_TYPE","VALID_TYPES","DEFAULT_TYPES","createContentTypeSchema","data","isEdition","kind","getOr","contentTypeSchema","createSchema","modelType","modelTypes","CONTENT_TYPE","shape","displayName","yup","string","min","required","singularName","test","nameIsAvailable","forbiddenContentTypeNameValidator","isKebabCase","pluralName","nameIsNotExistingCollectionName","value","object","contentType","noUnknown","components","nestedComponentSchema","validateContentTypeInput","validateYupSchema","validateUpdateContentTypeInput","has","removeEmptyDefaults","removeDeletedUIDTargetFields","Array","isArray","forEach","comp","reservedNames","getService","getReservedNames","models","name","message","join","isReservedModelName","usedNames","flatMap","ct","info","strapi","contentTypes","every","usedName","snakeCase","Object","keys","map","key","collectionName","kindSchema","oneOf","validateKind"],"mappings":"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"}
1	+ {"version":3,"file":"content-type.js","sources":["../../../../server/src/controllers/validation/content-type.ts"],"sourcesContent":["import { get, has, snakeCase } from 'lodash';\n/* eslint-disable no-template-curly-in-string / // yup templates need to be in this format\n\nimport { yup, validateYupSchema } from '@strapi/utils';\n\nimport type { Struct, Internal, UID } from '@strapi/types';\n\nimport { getService } from '../../utils';\nimport { modelTypes, DEFAULT_TYPES, typeKinds } from '../../services/constants';\nimport { createSchema } from './model-schema';\nimport { removeEmptyDefaults, removeDeletedUIDTargetFields } from './data-transform';\nimport { nestedComponentSchema } from './component';\n\n// Input flattens some fields of the \"info\" into the root type\nexport type CreateContentTypeInput = {\n uid?: UID.ContentType;\n contentType?: Partial<Struct.ContentTypeSchema> & Partial<Struct.ContentTypeSchemaInfo>;\n components?: Array<\n Partial<Struct.ComponentSchema> &\n Partial<Struct.SchemaInfo> & { tmpUID?: Internal.UID.Component }\n >;\n singularName: Struct.ContentTypeSchemaInfo['singularName'];\n attributes: Struct.SchemaAttributes & Record<string, any>;\n kind: Struct.ContentTypeKind;\n collectionName?: Struct.CollectionTypeSchema['collectionName'];\n pluralName: Struct.ContentTypeSchemaInfo['pluralName'];\n displayName: Struct.ContentTypeSchemaInfo['displayName'];\n description?: Struct.ContentTypeSchemaInfo['description'];\n options?: Struct.SchemaOptions;\n draftAndPublish?: Struct.SchemaOptions['draftAndPublish'];\n pluginOptions?: Struct.ContentTypeSchema['pluginOptions'];\n config?: object;\n plugin?: string;\n};\n\n/\n Allowed relation per type kind\n /\nconst VALID_RELATIONS = {\n [typeKinds.SINGLE_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n [typeKinds.COLLECTION_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'manyToOne',\n 'manyToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n} as const;\n\n/\n Allowed types\n /\nconst VALID_TYPES = [...DEFAULT_TYPES, 'uid', 'component', 'dynamiczone', 'customField'];\n\n/\n Returns a yup schema to validate a content type payload\n /\nconst createContentTypeSchema = (data: CreateContentTypeInput, { isEdition = false } = {}) => {\n const kind: keyof typeof VALID_RELATIONS = get(\n data,\n 'contentType.kind',\n typeKinds.COLLECTION_TYPE\n );\n\n const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] \|\| [], {\n modelType: modelTypes.CONTENT_TYPE,\n })\n .shape({\n displayName: yup.string().min(1).required(),\n singularName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n pluralName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(nameIsNotExistingCollectionName(isEdition)) // TODO: v5: require singularName to not match a collection name\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n })\n .test(\n 'singularName-not-equal-pluralName',\n '${path}: singularName and pluralName should be different',\n (value) => value.singularName !== value.pluralName\n );\n\n return yup\n .object({\n // FIXME .noUnknown(false) will strip off the unwanted properties without throwing an error\n // Why not having .noUnknown() ? Because we want to be able to add options relatable to EE features\n // without having any reference to them in CE.\n // Why not handle an \"options\" object in the content-type ? The admin panel needs lots of rework\n // to be able to send this options object instead of top-level attributes.\n // @nathan-pichon 20/02/2023\n contentType: contentTypeSchema.required().noUnknown(false),\n components: nestedComponentSchema,\n })\n .noUnknown();\n};\n\n/\n Validator for content type creation\n /\nexport const validateContentTypeInput = (data: CreateContentTypeInput) => {\n return validateYupSchema(createContentTypeSchema(data))(data);\n};\n\n/\n Validator for content type edition\n /\nexport const validateUpdateContentTypeInput = (data: CreateContentTypeInput) => {\n if (has(data, 'contentType')) {\n removeEmptyDefaults(data.contentType);\n removeDeletedUIDTargetFields(data.contentType as Struct.ContentTypeSchema);\n }\n\n if (has(data, 'components') && Array.isArray(data.components)) {\n data.components.forEach((comp) => {\n if (has(comp, 'uid')) {\n removeEmptyDefaults(comp as Struct.ComponentSchema);\n }\n });\n }\n\n return validateYupSchema(createContentTypeSchema(data, { isEdition: true }))(data);\n};\n\nconst forbiddenContentTypeNameValidator = () => {\n const reservedNames = getService('builder').getReservedNames().models;\n\n return {\n name: 'forbiddenContentTypeName',\n message: `Content Type name cannot be one of ${reservedNames.join(', ')}`,\n test(value: unknown) {\n if (typeof value !== 'string') {\n return true;\n }\n\n return !getService('builder').isReservedModelName(value);\n },\n };\n};\n\nconst nameIsAvailable = (isEdition: boolean) => {\n const usedNames = Object.values(strapi.contentTypes).flatMap((ct) => {\n return [ct.info?.singularName, ct.info?.pluralName];\n });\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\nconst nameIsNotExistingCollectionName = (isEdition: boolean) => {\n const usedNames = Object.keys(strapi.contentTypes).map(\n (key) => strapi.contentTypes[key as Internal.UID.ContentType].collectionName\n ) as string[];\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\n/\n Validates type kind\n */\nconst kindSchema = yup.string().oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE]);\n\nexport const validateKind = validateYupSchema(kindSchema);\n"],"names":["VALID_RELATIONS","typeKinds","SINGLE_TYPE","COLLECTION_TYPE","VALID_TYPES","DEFAULT_TYPES","createContentTypeSchema","data","isEdition","kind","get","contentTypeSchema","createSchema","modelType","modelTypes","CONTENT_TYPE","shape","displayName","yup","string","min","required","singularName","test","nameIsAvailable","forbiddenContentTypeNameValidator","isKebabCase","pluralName","nameIsNotExistingCollectionName","value","object","contentType","noUnknown","components","nestedComponentSchema","validateContentTypeInput","validateYupSchema","validateUpdateContentTypeInput","has","removeEmptyDefaults","removeDeletedUIDTargetFields","Array","isArray","forEach","comp","reservedNames","getService","getReservedNames","models","name","message","join","isReservedModelName","usedNames","Object","values","strapi","contentTypes","flatMap","ct","info","every","usedName","snakeCase","keys","map","key","collectionName","kindSchema","oneOf","validateKind"],"mappings":"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"}

package/dist/server/controllers/validation/content-type.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-import { has, getOr, flatMap, snakeCase } from 'lodash/fp';
+import { has, get, snakeCase } from 'lodash';
 import { yup, validateYupSchema } from '@strapi/utils';
 import { getService } from '../../utils/index.mjs';
 import { typeKinds, modelTypes, DEFAULT_TYPES } from '../../services/constants.mjs';
@@ -6,7 +6,6 @@ import { createSchema } from './model-schema.mjs';
 import { removeEmptyDefaults, removeDeletedUIDTargetFields } from './data-transform.mjs';
 import { nestedComponentSchema } from './component.mjs';
-/* eslint-disable no-template-curly-in-string */ // yup templates need to be in this format
 /**
  * Allowed relation per type kind
  */ const VALID_RELATIONS = {
@@ -41,7 +40,7 @@ import { nestedComponentSchema } from './component.mjs';
 /**
  * Returns a yup schema to validate a content type payload
  */ const createContentTypeSchema = (data, { isEdition = false } = {})=>{
-    const kind = getOr(typeKinds.COLLECTION_TYPE, 'contentType.kind', data);
+    const kind = get(data, 'contentType.kind', typeKinds.COLLECTION_TYPE);
     const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] || [], {
         modelType: modelTypes.CONTENT_TYPE
     }).shape({
@@ -69,13 +68,13 @@ import { nestedComponentSchema } from './component.mjs';
 /**
  * Validator for content type edition
  */ const validateUpdateContentTypeInput = (data)=>{
-    if (has('contentType', data)) {
+    if (has(data, 'contentType')) {
         removeEmptyDefaults(data.contentType);
         removeDeletedUIDTargetFields(data.contentType);
     }
-    if (has('components', data) && Array.isArray(data.components)) {
+    if (has(data, 'components') && Array.isArray(data.components)) {
         data.components.forEach((comp)=>{
-            if (has('uid', comp)) {
+            if (has(comp, 'uid')) {
                 removeEmptyDefaults(comp);
             }
         });
@@ -98,13 +97,12 @@ const forbiddenContentTypeNameValidator = ()=>{
     };
 };
 const nameIsAvailable = (isEdition)=>{
-    // TODO TS: if strapi.contentTypes (ie, ContentTypes) works as an ArrayLike and is used like this, we may want to ensure it is typed so that it can be without using as
-    const usedNames = flatMap((ct)=>{
+    const usedNames = Object.values(strapi.contentTypes).flatMap((ct)=>{
         return [
             ct.info?.singularName,
             ct.info?.pluralName
         ];
-    })(strapi.contentTypes);
+    });
     return {
         name: 'nameAlreadyUsed',
         message: 'contentType: name `${value}` is already being used by another content type.',

package/dist/server/controllers/validation/content-type.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"content-type.mjs","sources":["../../../../server/src/controllers/validation/content-type.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string / // yup templates need to be in this format\n\nimport { flatMap, getOr, has, snakeCase } from 'lodash/fp';\nimport { yup, validateYupSchema } from '@strapi/utils';\n\nimport type { Struct, Internal, UID } from '@strapi/types';\n\nimport { getService } from '../../utils';\nimport { modelTypes, DEFAULT_TYPES, typeKinds } from '../../services/constants';\nimport { createSchema } from './model-schema';\nimport { removeEmptyDefaults, removeDeletedUIDTargetFields } from './data-transform';\nimport { nestedComponentSchema } from './component';\n\n// Input flattens some fields of the \"info\" into the root type\nexport type CreateContentTypeInput = {\n uid?: UID.ContentType;\n contentType?: Partial<Struct.ContentTypeSchema> & Partial<Struct.ContentTypeSchemaInfo>;\n components?: Array<\n Partial<Struct.ComponentSchema> &\n Partial<Struct.SchemaInfo> & { tmpUID?: Internal.UID.Component }\n >;\n singularName: Struct.ContentTypeSchemaInfo['singularName'];\n attributes: Struct.SchemaAttributes & Record<string, any>;\n kind: Struct.ContentTypeKind;\n collectionName?: Struct.CollectionTypeSchema['collectionName'];\n pluralName: Struct.ContentTypeSchemaInfo['pluralName'];\n displayName: Struct.ContentTypeSchemaInfo['displayName'];\n description?: Struct.ContentTypeSchemaInfo['description'];\n options?: Struct.SchemaOptions;\n draftAndPublish?: Struct.SchemaOptions['draftAndPublish'];\n pluginOptions?: Struct.ContentTypeSchema['pluginOptions'];\n config?: object;\n plugin?: string;\n};\n\n/\n Allowed relation per type kind\n /\nconst VALID_RELATIONS = {\n [typeKinds.SINGLE_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n [typeKinds.COLLECTION_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'manyToOne',\n 'manyToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n} as const;\n\n/\n Allowed types\n /\nconst VALID_TYPES = [...DEFAULT_TYPES, 'uid', 'component', 'dynamiczone', 'customField'];\n\n/\n Returns a yup schema to validate a content type payload\n /\nconst createContentTypeSchema = (data: CreateContentTypeInput, { isEdition = false } = {}) => {\n const kind: keyof typeof VALID_RELATIONS = getOr(\n typeKinds.COLLECTION_TYPE,\n 'contentType.kind',\n data\n );\n\n const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] \|\| [], {\n modelType: modelTypes.CONTENT_TYPE,\n })\n .shape({\n displayName: yup.string().min(1).required(),\n singularName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n pluralName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(nameIsNotExistingCollectionName(isEdition)) // TODO: v5: require singularName to not match a collection name\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n })\n .test(\n 'singularName-not-equal-pluralName',\n '${path}: singularName and pluralName should be different',\n (value) => value.singularName !== value.pluralName\n );\n\n return yup\n .object({\n // FIXME .noUnknown(false) will strip off the unwanted properties without throwing an error\n // Why not having .noUnknown() ? Because we want to be able to add options relatable to EE features\n // without having any reference to them in CE.\n // Why not handle an \"options\" object in the content-type ? The admin panel needs lots of rework\n // to be able to send this options object instead of top-level attributes.\n // @nathan-pichon 20/02/2023\n contentType: contentTypeSchema.required().noUnknown(false),\n components: nestedComponentSchema,\n })\n .noUnknown();\n};\n\n/\n Validator for content type creation\n /\nexport const validateContentTypeInput = (data: CreateContentTypeInput) => {\n return validateYupSchema(createContentTypeSchema(data))(data);\n};\n\n/\n Validator for content type edition\n /\nexport const validateUpdateContentTypeInput = (data: CreateContentTypeInput) => {\n if (has('contentType', data)) {\n removeEmptyDefaults(data.contentType);\n removeDeletedUIDTargetFields(data.contentType as Struct.ContentTypeSchema);\n }\n\n if (has('components', data) && Array.isArray(data.components)) {\n data.components.forEach((comp) => {\n if (has('uid', comp)) {\n removeEmptyDefaults(comp as Struct.ComponentSchema);\n }\n });\n }\n\n return validateYupSchema(createContentTypeSchema(data, { isEdition: true }))(data);\n};\n\nconst forbiddenContentTypeNameValidator = () => {\n const reservedNames = getService('builder').getReservedNames().models;\n\n return {\n name: 'forbiddenContentTypeName',\n message: `Content Type name cannot be one of ${reservedNames.join(', ')}`,\n test(value: unknown) {\n if (typeof value !== 'string') {\n return true;\n }\n\n return !getService('builder').isReservedModelName(value);\n },\n };\n};\n\nconst nameIsAvailable = (isEdition: boolean) => {\n // TODO TS: if strapi.contentTypes (ie, ContentTypes) works as an ArrayLike and is used like this, we may want to ensure it is typed so that it can be without using as\n const usedNames = flatMap((ct: Struct.ContentTypeSchema) => {\n return [ct.info?.singularName, ct.info?.pluralName];\n })(strapi.contentTypes as any);\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\nconst nameIsNotExistingCollectionName = (isEdition: boolean) => {\n const usedNames = Object.keys(strapi.contentTypes).map(\n (key) => strapi.contentTypes[key as Internal.UID.ContentType].collectionName\n ) as string[];\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\n/\n Validates type kind\n */\nconst kindSchema = yup.string().oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE]);\n\nexport const validateKind = validateYupSchema(kindSchema);\n"],"names":["VALID_RELATIONS","typeKinds","SINGLE_TYPE","COLLECTION_TYPE","VALID_TYPES","DEFAULT_TYPES","createContentTypeSchema","data","isEdition","kind","getOr","contentTypeSchema","createSchema","modelType","modelTypes","CONTENT_TYPE","shape","displayName","yup","string","min","required","singularName","test","nameIsAvailable","forbiddenContentTypeNameValidator","isKebabCase","pluralName","nameIsNotExistingCollectionName","value","object","contentType","noUnknown","components","nestedComponentSchema","validateContentTypeInput","validateYupSchema","validateUpdateContentTypeInput","has","removeEmptyDefaults","removeDeletedUIDTargetFields","Array","isArray","forEach","comp","reservedNames","getService","getReservedNames","models","name","message","join","isReservedModelName","usedNames","flatMap","ct","info","strapi","contentTypes","every","usedName","snakeCase","Object","keys","map","key","collectionName","kindSchema","oneOf","validateKind"],"mappings":"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"}
1	+ {"version":3,"file":"content-type.mjs","sources":["../../../../server/src/controllers/validation/content-type.ts"],"sourcesContent":["import { get, has, snakeCase } from 'lodash';\n/* eslint-disable no-template-curly-in-string / // yup templates need to be in this format\n\nimport { yup, validateYupSchema } from '@strapi/utils';\n\nimport type { Struct, Internal, UID } from '@strapi/types';\n\nimport { getService } from '../../utils';\nimport { modelTypes, DEFAULT_TYPES, typeKinds } from '../../services/constants';\nimport { createSchema } from './model-schema';\nimport { removeEmptyDefaults, removeDeletedUIDTargetFields } from './data-transform';\nimport { nestedComponentSchema } from './component';\n\n// Input flattens some fields of the \"info\" into the root type\nexport type CreateContentTypeInput = {\n uid?: UID.ContentType;\n contentType?: Partial<Struct.ContentTypeSchema> & Partial<Struct.ContentTypeSchemaInfo>;\n components?: Array<\n Partial<Struct.ComponentSchema> &\n Partial<Struct.SchemaInfo> & { tmpUID?: Internal.UID.Component }\n >;\n singularName: Struct.ContentTypeSchemaInfo['singularName'];\n attributes: Struct.SchemaAttributes & Record<string, any>;\n kind: Struct.ContentTypeKind;\n collectionName?: Struct.CollectionTypeSchema['collectionName'];\n pluralName: Struct.ContentTypeSchemaInfo['pluralName'];\n displayName: Struct.ContentTypeSchemaInfo['displayName'];\n description?: Struct.ContentTypeSchemaInfo['description'];\n options?: Struct.SchemaOptions;\n draftAndPublish?: Struct.SchemaOptions['draftAndPublish'];\n pluginOptions?: Struct.ContentTypeSchema['pluginOptions'];\n config?: object;\n plugin?: string;\n};\n\n/\n Allowed relation per type kind\n /\nconst VALID_RELATIONS = {\n [typeKinds.SINGLE_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n [typeKinds.COLLECTION_TYPE]: [\n 'oneToOne',\n 'oneToMany',\n 'manyToOne',\n 'manyToMany',\n 'morphOne',\n 'morphMany',\n 'morphToOne',\n 'morphToMany',\n ],\n} as const;\n\n/\n Allowed types\n /\nconst VALID_TYPES = [...DEFAULT_TYPES, 'uid', 'component', 'dynamiczone', 'customField'];\n\n/\n Returns a yup schema to validate a content type payload\n /\nconst createContentTypeSchema = (data: CreateContentTypeInput, { isEdition = false } = {}) => {\n const kind: keyof typeof VALID_RELATIONS = get(\n data,\n 'contentType.kind',\n typeKinds.COLLECTION_TYPE\n );\n\n const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS[kind] \|\| [], {\n modelType: modelTypes.CONTENT_TYPE,\n })\n .shape({\n displayName: yup.string().min(1).required(),\n singularName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n pluralName: yup\n .string()\n .min(1)\n .test(nameIsAvailable(isEdition))\n .test(nameIsNotExistingCollectionName(isEdition)) // TODO: v5: require singularName to not match a collection name\n .test(forbiddenContentTypeNameValidator())\n .isKebabCase()\n .required(),\n })\n .test(\n 'singularName-not-equal-pluralName',\n '${path}: singularName and pluralName should be different',\n (value) => value.singularName !== value.pluralName\n );\n\n return yup\n .object({\n // FIXME .noUnknown(false) will strip off the unwanted properties without throwing an error\n // Why not having .noUnknown() ? Because we want to be able to add options relatable to EE features\n // without having any reference to them in CE.\n // Why not handle an \"options\" object in the content-type ? The admin panel needs lots of rework\n // to be able to send this options object instead of top-level attributes.\n // @nathan-pichon 20/02/2023\n contentType: contentTypeSchema.required().noUnknown(false),\n components: nestedComponentSchema,\n })\n .noUnknown();\n};\n\n/\n Validator for content type creation\n /\nexport const validateContentTypeInput = (data: CreateContentTypeInput) => {\n return validateYupSchema(createContentTypeSchema(data))(data);\n};\n\n/\n Validator for content type edition\n /\nexport const validateUpdateContentTypeInput = (data: CreateContentTypeInput) => {\n if (has(data, 'contentType')) {\n removeEmptyDefaults(data.contentType);\n removeDeletedUIDTargetFields(data.contentType as Struct.ContentTypeSchema);\n }\n\n if (has(data, 'components') && Array.isArray(data.components)) {\n data.components.forEach((comp) => {\n if (has(comp, 'uid')) {\n removeEmptyDefaults(comp as Struct.ComponentSchema);\n }\n });\n }\n\n return validateYupSchema(createContentTypeSchema(data, { isEdition: true }))(data);\n};\n\nconst forbiddenContentTypeNameValidator = () => {\n const reservedNames = getService('builder').getReservedNames().models;\n\n return {\n name: 'forbiddenContentTypeName',\n message: `Content Type name cannot be one of ${reservedNames.join(', ')}`,\n test(value: unknown) {\n if (typeof value !== 'string') {\n return true;\n }\n\n return !getService('builder').isReservedModelName(value);\n },\n };\n};\n\nconst nameIsAvailable = (isEdition: boolean) => {\n const usedNames = Object.values(strapi.contentTypes).flatMap((ct) => {\n return [ct.info?.singularName, ct.info?.pluralName];\n });\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\nconst nameIsNotExistingCollectionName = (isEdition: boolean) => {\n const usedNames = Object.keys(strapi.contentTypes).map(\n (key) => strapi.contentTypes[key as Internal.UID.ContentType].collectionName\n ) as string[];\n\n return {\n name: 'nameAlreadyUsed',\n message: 'contentType: name `${value}` is already being used by another content type.',\n test(value: unknown) {\n // don't check on edition\n if (isEdition) return true;\n\n // ignore if not a string (will be caught in another validator)\n if (typeof value !== 'string') {\n return true;\n }\n\n // compare snake case to check the actual column names that will be used in the database\n return usedNames.every((usedName) => snakeCase(usedName) !== snakeCase(value));\n },\n };\n};\n\n/\n Validates type kind\n */\nconst kindSchema = yup.string().oneOf([typeKinds.SINGLE_TYPE, typeKinds.COLLECTION_TYPE]);\n\nexport const validateKind = validateYupSchema(kindSchema);\n"],"names":["VALID_RELATIONS","typeKinds","SINGLE_TYPE","COLLECTION_TYPE","VALID_TYPES","DEFAULT_TYPES","createContentTypeSchema","data","isEdition","kind","get","contentTypeSchema","createSchema","modelType","modelTypes","CONTENT_TYPE","shape","displayName","yup","string","min","required","singularName","test","nameIsAvailable","forbiddenContentTypeNameValidator","isKebabCase","pluralName","nameIsNotExistingCollectionName","value","object","contentType","noUnknown","components","nestedComponentSchema","validateContentTypeInput","validateYupSchema","validateUpdateContentTypeInput","has","removeEmptyDefaults","removeDeletedUIDTargetFields","Array","isArray","forEach","comp","reservedNames","getService","getReservedNames","models","name","message","join","isReservedModelName","usedNames","Object","values","strapi","contentTypes","flatMap","ct","info","every","usedName","snakeCase","keys","map","key","collectionName","kindSchema","oneOf","validateKind"],"mappings":"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"}

package/dist/server/controllers/validation/model-schema.js CHANGED Viewed

@@ -2,7 +2,6 @@
 var utils = require('@strapi/utils');
 var _ = require('lodash');
-var fp = require('lodash/fp');
 var constants = require('../../services/constants.js');
 var index = require('../../utils/index.js');
 var common = require('./common.js');
@@ -58,10 +57,10 @@ const createAttributesValidator = ({ types: types$1, modelType, relations: relat
     });
 };
 const isConflictingKey = (key, attributes)=>{
-    const snakeCaseKey = fp.snakeCase(key);
+    const snakeCaseKey = _.snakeCase(key);
     return Object.keys(attributes).some((existingKey)=>{
         if (existingKey === key) return false; // don't compare against itself
-        return fp.snakeCase(existingKey) === snakeCaseKey;
+        return _.snakeCase(existingKey) === snakeCaseKey;
     });
 };
 const isForbiddenKey = (key)=>{