@strapi/content-type-builder 5.54.0 → 5.55.1

package/dist/admin/src/utils/folderTelemetry.d.ts

@@ -0,0 +1,5 @@
+export declare const DID_ACT_ON_FOLDERS = "didActOnFolders";
+export type FolderAction = 'create' | 'rename' | 'move' | 'deleteOnly' | 'deleteSubtree' | 'assign' | 'reorder';
+export type FolderTelemetryOperation = 'create' | 'update' | 'delete';
+/** Map a fine-grained folder action to an operation value the telemetry API accepts. */
+export declare const folderTelemetryOperation: (action: FolderAction) => FolderTelemetryOperation;

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

@@ -60,6 +60,8 @@ var en = {
     "contentType.collectionName.description": "Useful when the name of your Content Type and your table name differ",
     "contentType.collectionName.label": "Collection name",
     "contentType.displayName.label": "Display name",
+    "contentType.folder.label": "Select a folder or enter a value to create a new one",
+    "contentType.folder.placeholder": "Select or enter a value",
     "contentType.kind.change.warning": "You just changed the kind of a content type: API will be reset (routes, controllers, and services will be overwritten).",
     "error.attributeName.reserved-name": "This name cannot be used in your content type as it might break other functionalities",
     "error.contentType.pluralName-used": "This value cannot be the same as the singular one",
@@ -171,6 +173,27 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "nav.action.new-collection-type": "New Collection-Type",
+    "nav.action.new-folder": "New folder",
+    "nav.action.new-single-type": "New Single-Type",
+    "nav.drag.handle-label": "Move {name}",
+    "nav.folder.actions-label": "Actions for {name}",
+    "nav.folder.default-name": "New folder",
+    "nav.folder.delete": "Delete folder",
+    "nav.folder.delete-with-content": "Delete folder and contents",
+    "nav.folder.delete-with-content.body": "You are about to delete the folder named {name} and its deletable contents ({contentTypes, plural, =0 {{subfolders, plural, one {# subfolder} other {# subfolders}}} one {# application content type{subfolders, plural, =0 {} one {, # subfolder} other {, # subfolders}}} other {# application content types{subfolders, plural, =0 {} one {, # subfolder} other {, # subfolders}}}}). Are you sure you want to proceed?",
+    "nav.folder.delete-with-content.preserved": "{preservedContentTypes, plural, one {# protected content type will be preserved and ungrouped.} other {# protected content types will be preserved and ungrouped.}}",
+    "nav.folder.delete.blocked": "This folder cannot be deleted because these folder names already exist in its destination: {names}.",
+    "nav.folder.delete-with-content.title": "Delete folder and contents",
+    "nav.folder.delete.body": "You are about to delete the folder named {name}. Are you sure you want to proceed?",
+    "nav.folder.delete.cancel": "No, cancel",
+    "nav.folder.delete.confirm": "Yes, delete",
+    "nav.folder.delete.title": "Delete folder",
+    "nav.folder.dragging": "Dragging {name}",
+    "nav.folder.empty": "Empty folder",
+    "nav.folder.name-label": "Folder name",
+    "nav.folder.name.duplicate": "A folder with this name already exists in this location",
+    "nav.folder.rename": "Rename",
     "modalForm.attribute.form.base.name.description": "No space is allowed for the name of the attribute",
     "modalForm.attribute.form.base.name.placeholder": "e.g. slug, seoUrl, canonicalUrl",
     "modalForm.attribute.target-field": "Attached field",

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

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

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

@@ -56,6 +56,8 @@ var en = {
     "contentType.collectionName.description": "Useful when the name of your Content Type and your table name differ",
     "contentType.collectionName.label": "Collection name",
     "contentType.displayName.label": "Display name",
+    "contentType.folder.label": "Select a folder or enter a value to create a new one",
+    "contentType.folder.placeholder": "Select or enter a value",
     "contentType.kind.change.warning": "You just changed the kind of a content type: API will be reset (routes, controllers, and services will be overwritten).",
     "error.attributeName.reserved-name": "This name cannot be used in your content type as it might break other functionalities",
     "error.contentType.pluralName-used": "This value cannot be the same as the singular one",
@@ -167,6 +169,27 @@ var en = {
     "menu.section.components.name": "Components",
     "menu.section.models.name": "Collection Types",
     "menu.section.single-types.name": "Single Types",
+    "nav.action.new-collection-type": "New Collection-Type",
+    "nav.action.new-folder": "New folder",
+    "nav.action.new-single-type": "New Single-Type",
+    "nav.drag.handle-label": "Move {name}",
+    "nav.folder.actions-label": "Actions for {name}",
+    "nav.folder.default-name": "New folder",
+    "nav.folder.delete": "Delete folder",
+    "nav.folder.delete-with-content": "Delete folder and contents",
+    "nav.folder.delete-with-content.body": "You are about to delete the folder named {name} and its deletable contents ({contentTypes, plural, =0 {{subfolders, plural, one {# subfolder} other {# subfolders}}} one {# application content type{subfolders, plural, =0 {} one {, # subfolder} other {, # subfolders}}} other {# application content types{subfolders, plural, =0 {} one {, # subfolder} other {, # subfolders}}}}). Are you sure you want to proceed?",
+    "nav.folder.delete-with-content.preserved": "{preservedContentTypes, plural, one {# protected content type will be preserved and ungrouped.} other {# protected content types will be preserved and ungrouped.}}",
+    "nav.folder.delete.blocked": "This folder cannot be deleted because these folder names already exist in its destination: {names}.",
+    "nav.folder.delete-with-content.title": "Delete folder and contents",
+    "nav.folder.delete.body": "You are about to delete the folder named {name}. Are you sure you want to proceed?",
+    "nav.folder.delete.cancel": "No, cancel",
+    "nav.folder.delete.confirm": "Yes, delete",
+    "nav.folder.delete.title": "Delete folder",
+    "nav.folder.dragging": "Dragging {name}",
+    "nav.folder.empty": "Empty folder",
+    "nav.folder.name-label": "Folder name",
+    "nav.folder.name.duplicate": "A folder with this name already exists in this location",
+    "nav.folder.rename": "Rename",
     "modalForm.attribute.form.base.name.description": "No space is allowed for the name of the attribute",
     "modalForm.attribute.form.base.name.placeholder": "e.g. slug, seoUrl, canonicalUrl",
     "modalForm.attribute.target-field": "Attached field",

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

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

package/dist/admin/utils/folderTelemetry.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const DID_ACT_ON_FOLDERS = 'didActOnFolders';
+const OPERATION_BY_ACTION = {
+    create: 'create',
+    rename: 'update',
+    move: 'update',
+    assign: 'update',
+    reorder: 'update',
+    deleteOnly: 'delete',
+    deleteSubtree: 'delete'
+};
+/** Map a fine-grained folder action to an operation value the telemetry API accepts. */ const folderTelemetryOperation = (action)=>{
+    return OPERATION_BY_ACTION[action];
+};
+
+exports.DID_ACT_ON_FOLDERS = DID_ACT_ON_FOLDERS;
+exports.folderTelemetryOperation = folderTelemetryOperation;
+//# sourceMappingURL=folderTelemetry.js.map

package/dist/admin/utils/folderTelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"folderTelemetry.js","sources":["../../../admin/src/utils/folderTelemetry.ts"],"sourcesContent":["export const DID_ACT_ON_FOLDERS = 'didActOnFolders';\n\nexport type FolderAction =\n  | 'create'\n  | 'rename'\n  | 'move'\n  | 'deleteOnly'\n  | 'deleteSubtree'\n  | 'assign'\n  | 'reorder';\n\nexport type FolderTelemetryOperation = 'create' | 'update' | 'delete';\n\nconst OPERATION_BY_ACTION: Record<FolderAction, FolderTelemetryOperation> = {\n  create: 'create',\n  rename: 'update',\n  move: 'update',\n  assign: 'update',\n  reorder: 'update',\n  deleteOnly: 'delete',\n  deleteSubtree: 'delete',\n};\n\n/** Map a fine-grained folder action to an operation value the telemetry API accepts. */\nexport const folderTelemetryOperation = (action: FolderAction): FolderTelemetryOperation => {\n  return OPERATION_BY_ACTION[action];\n};\n"],"names":["DID_ACT_ON_FOLDERS","OPERATION_BY_ACTION","create","rename","move","assign","reorder","deleteOnly","deleteSubtree","folderTelemetryOperation","action"],"mappings":";;AAAO,MAAMA,qBAAqB;AAalC,MAAMC,mBAAAA,GAAsE;IAC1EC,MAAAA,EAAQ,QAAA;IACRC,MAAAA,EAAQ,QAAA;IACRC,IAAAA,EAAM,QAAA;IACNC,MAAAA,EAAQ,QAAA;IACRC,OAAAA,EAAS,QAAA;IACTC,UAAAA,EAAY,QAAA;IACZC,aAAAA,EAAe;AACjB,CAAA;AAEA,yFACO,MAAMC,wBAAAA,GAA2B,CAACC,MAAAA,GAAAA;IACvC,OAAOT,mBAAmB,CAACS,MAAAA,CAAO;AACpC;;;;;"}

package/dist/admin/utils/folderTelemetry.mjs

@@ -0,0 +1,16 @@
+const DID_ACT_ON_FOLDERS = 'didActOnFolders';
+const OPERATION_BY_ACTION = {
+    create: 'create',
+    rename: 'update',
+    move: 'update',
+    assign: 'update',
+    reorder: 'update',
+    deleteOnly: 'delete',
+    deleteSubtree: 'delete'
+};
+/** Map a fine-grained folder action to an operation value the telemetry API accepts. */ const folderTelemetryOperation = (action)=>{
+    return OPERATION_BY_ACTION[action];
+};
+
+export { DID_ACT_ON_FOLDERS, folderTelemetryOperation };
+//# sourceMappingURL=folderTelemetry.mjs.map

package/dist/admin/utils/folderTelemetry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"folderTelemetry.mjs","sources":["../../../admin/src/utils/folderTelemetry.ts"],"sourcesContent":["export const DID_ACT_ON_FOLDERS = 'didActOnFolders';\n\nexport type FolderAction =\n  | 'create'\n  | 'rename'\n  | 'move'\n  | 'deleteOnly'\n  | 'deleteSubtree'\n  | 'assign'\n  | 'reorder';\n\nexport type FolderTelemetryOperation = 'create' | 'update' | 'delete';\n\nconst OPERATION_BY_ACTION: Record<FolderAction, FolderTelemetryOperation> = {\n  create: 'create',\n  rename: 'update',\n  move: 'update',\n  assign: 'update',\n  reorder: 'update',\n  deleteOnly: 'delete',\n  deleteSubtree: 'delete',\n};\n\n/** Map a fine-grained folder action to an operation value the telemetry API accepts. */\nexport const folderTelemetryOperation = (action: FolderAction): FolderTelemetryOperation => {\n  return OPERATION_BY_ACTION[action];\n};\n"],"names":["DID_ACT_ON_FOLDERS","OPERATION_BY_ACTION","create","rename","move","assign","reorder","deleteOnly","deleteSubtree","folderTelemetryOperation","action"],"mappings":"AAAO,MAAMA,qBAAqB;AAalC,MAAMC,mBAAAA,GAAsE;IAC1EC,MAAAA,EAAQ,QAAA;IACRC,MAAAA,EAAQ,QAAA;IACRC,IAAAA,EAAM,QAAA;IACNC,MAAAA,EAAQ,QAAA;IACRC,OAAAA,EAAS,QAAA;IACTC,UAAAA,EAAY,QAAA;IACZC,aAAAA,EAAe;AACjB,CAAA;AAEA,yFACO,MAAMC,wBAAAA,GAA2B,CAACC,MAAAA,GAAAA;IACvC,OAAOT,mBAAmB,CAACS,MAAAA,CAAO;AACpC;;;;"}

package/dist/server/controllers/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)) {
+                if (fp.isEmpty(data.components) && fp.isEmpty(data.contentTypes) && fp.isEmpty(data.contentStructure)) {
                     ctx.body = {};
                     return;
                 }

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

@@ -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 (isEmpty(data.components) && isEmpty(data.contentTypes)) {\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","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;AAE5D,gBAAA,IAAIC,WAAQN,IAAAA,CAAKO,UAAU,KAAKD,UAAAA,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,EAAG;oBAC1DZ,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBe,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMb,gBAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCY,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAd,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOQ,KAAAA,EAAO;AACdpB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMoB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOjB,GAAAA,CAAIG,IAAI,CAAC;oBAAEc,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBtB,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;;;;"}
+{"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;;;;"}

package/dist/server/controllers/schema.mjs

@@ -19,7 +19,7 @@ var schema = (()=>{
             }
             try {
                 const { data } = await validateUpdateSchema(ctx.request.body);
-                if (isEmpty(data.components) && isEmpty(data.contentTypes)) {
+                if (isEmpty(data.components) && isEmpty(data.contentTypes) && isEmpty(data.contentStructure)) {
                     ctx.body = {};
                     return;
                 }

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

@@ -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 (isEmpty(data.components) && isEmpty(data.contentTypes)) {\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","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;AAE5D,gBAAA,IAAIC,QAAQN,IAAAA,CAAKO,UAAU,KAAKD,OAAAA,CAAQN,IAAAA,CAAKQ,YAAY,CAAA,EAAG;oBAC1DZ,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACZ,oBAAA;AACF,gBAAA;AAEAZ,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,IAAA;gBACvBe,MAAAA,CAAOC,MAAM,CAACC,UAAU,GAAG,KAAA;gBAE3B,MAAMb,UAAAA,CAAW,QAAA,CAAA,CAAUG,YAAY,CAACD,IAAAA,CAAAA;;;gBAIxCY,YAAAA,CAAa,IAAA;AACXH,oBAAAA,MAAAA,CAAOC,MAAM,EAAA;AACf,gBAAA,CAAA,CAAA;gBAEAd,GAAAA,CAAIS,IAAI,GAAG,EAAC;AACd,YAAA,CAAA,CAAE,OAAOQ,KAAAA,EAAO;AACdpB,gBAAAA,SAAAA,CAAUC,UAAU,GAAG,KAAA;AACvB,gBAAA,MAAMoB,eAAeD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMG,OAAO,GAAGC,MAAAA,CAAOJ,KAAAA,CAAAA;gBACrE,OAAOjB,GAAAA,CAAIG,IAAI,CAAC;oBAAEc,KAAAA,EAAOC;iBAAa,EAAG,GAAA,CAAA;AAC3C,YAAA;AACF,QAAA,CAAA;AAEA,QAAA,MAAMI,uBAAsBtB,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;;;;"}
+{"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;;;;"}

package/dist/server/controllers/validation/common.js

@@ -19,6 +19,8 @@ const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;
 const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;
 const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;
 const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+// Fully-qualified content-type uid: `api::a.a` / `plugin::p.p` / `strapi::x` / `admin::x`.
+const CONTENT_TYPE_UID_REGEX = /^((strapi|admin)::[\w-]+|(api|plugin)::[\w-]+\.[\w-]+)$/;
 const isValidName = {
     name: 'isValidName',
     message: `\${path} must match the following regex: ${NAME_REGEX}`,
@@ -85,6 +87,7 @@ const isValidDefaultJSON = {
 
 exports.CATEGORY_NAME_REGEX = CATEGORY_NAME_REGEX;
 exports.COLLECTION_NAME_REGEX = COLLECTION_NAME_REGEX;
+exports.CONTENT_TYPE_UID_REGEX = CONTENT_TYPE_UID_REGEX;
 exports.ICON_REGEX = ICON_REGEX;
 exports.KEBAB_BASE_REGEX = KEBAB_BASE_REGEX;
 exports.NAME_REGEX = NAME_REGEX;

package/dist/server/controllers/validation/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","sources":["../../../../server/src/controllers/validation/common.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string */\nimport { yup, strings } from '@strapi/utils';\nimport _ from 'lodash';\nimport { TestConfig } from 'yup';\n\nexport const validators = {\n  required: yup.boolean(),\n  unique: yup.boolean(),\n  minLength: yup.number().integer().positive(),\n  maxLength: yup.number().integer().positive(),\n};\n\nexport const NAME_REGEX = /^[A-Za-z][_0-9A-Za-z]*$/;\nexport const COLLECTION_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;\nexport const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;\nexport const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\n\nexport type CommonTestConfig = TestConfig<unknown | undefined, Record<string, unknown>>;\n\nexport const isValidName: CommonTestConfig = {\n  name: 'isValidName',\n  message: `\\${path} must match the following regex: ${NAME_REGEX}`,\n  test: (val: unknown) => val === '' || NAME_REGEX.test(val as string),\n};\n\nexport const isValidIcon: CommonTestConfig = {\n  name: 'isValidIcon',\n  message: `\\${path} is not a valid icon name. Make sure your icon name starts with an alphanumeric character and only includes alphanumeric characters or dashes.`,\n  test: (val) => val === '' || ICON_REGEX.test(val as string),\n};\n\nexport const isValidUID: CommonTestConfig = {\n  name: 'isValidUID',\n  message: `\\${path} must match the following regex: ${UID_REGEX}`,\n  test: (val) => val === '' || UID_REGEX.test(val as string),\n};\n\nexport const isValidCategoryName: CommonTestConfig = {\n  name: 'isValidCategoryName',\n  message: `\\${path} must start with a letter and only contain letters, numbers, dashes and underscores`,\n  test: (val) => val === '' || CATEGORY_NAME_REGEX.test(val as string),\n};\n\nexport const isValidCollectionName: CommonTestConfig = {\n  name: 'isValidCollectionName',\n  message: `\\${path} must match the following regex: ${COLLECTION_NAME_REGEX}`,\n  test: (val) => val === '' || COLLECTION_NAME_REGEX.test(val as string),\n};\n\nexport const isValidKey = (key: string): CommonTestConfig => ({\n  name: 'isValidKey',\n  message: `Attribute name '${key}' must match the following regex: ${NAME_REGEX}`,\n  test: () => NAME_REGEX.test(key),\n});\n\nexport const isValidEnum: CommonTestConfig = {\n  name: 'isValidEnum',\n  message: '${path} should not start with number',\n  test: (val) => val === '' || !strings.startsWithANumber(val as string),\n};\n\nexport const areEnumValuesUnique: CommonTestConfig = {\n  name: 'areEnumValuesUnique',\n  message: '${path} cannot contain duplicate values',\n  test(values) {\n    const filtered = [...new Set(values as string[])];\n\n    return filtered.length === (values as string[]).length;\n  },\n};\n\nexport const isValidRegExpPattern: CommonTestConfig = {\n  name: 'isValidRegExpPattern',\n  message: '${path} must be a valid RexExp pattern string',\n  test: (val) => val === '' || !!new RegExp(val as string),\n};\n\nexport const isValidDefaultJSON: CommonTestConfig = {\n  name: 'isValidDefaultJSON',\n  message: '${path} is not a valid JSON',\n  test(val) {\n    if (val === undefined) {\n      return true;\n    }\n\n    if (_.isNumber(val) || _.isNull(val) || _.isObject(val) || _.isArray(val)) {\n      return true;\n    }\n\n    try {\n      JSON.parse(val as string);\n\n      return true;\n    } catch {\n      return false;\n    }\n  },\n};\n"],"names":["validators","required","yup","boolean","unique","minLength","number","integer","positive","maxLength","NAME_REGEX","COLLECTION_NAME_REGEX","CATEGORY_NAME_REGEX","ICON_REGEX","UID_REGEX","KEBAB_BASE_REGEX","isValidName","name","message","test","val","isValidIcon","isValidCategoryName","isValidCollectionName","isValidKey","key","isValidEnum","strings","startsWithANumber","areEnumValuesUnique","values","filtered","Set","length","isValidRegExpPattern","RegExp","isValidDefaultJSON","undefined","_","isNumber","isNull","isObject","isArray","JSON","parse"],"mappings":"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"}
+{"version":3,"file":"common.js","sources":["../../../../server/src/controllers/validation/common.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string */\nimport { yup, strings } from '@strapi/utils';\nimport _ from 'lodash';\nimport { TestConfig } from 'yup';\n\nexport const validators = {\n  required: yup.boolean(),\n  unique: yup.boolean(),\n  minLength: yup.number().integer().positive(),\n  maxLength: yup.number().integer().positive(),\n};\n\nexport const NAME_REGEX = /^[A-Za-z][_0-9A-Za-z]*$/;\nexport const COLLECTION_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;\nexport const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;\nexport const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\n// Fully-qualified content-type uid: `api::a.a` / `plugin::p.p` / `strapi::x` / `admin::x`.\nexport const CONTENT_TYPE_UID_REGEX = /^((strapi|admin)::[\\w-]+|(api|plugin)::[\\w-]+\\.[\\w-]+)$/;\n\nexport type CommonTestConfig = TestConfig<unknown | undefined, Record<string, unknown>>;\n\nexport const isValidName: CommonTestConfig = {\n  name: 'isValidName',\n  message: `\\${path} must match the following regex: ${NAME_REGEX}`,\n  test: (val: unknown) => val === '' || NAME_REGEX.test(val as string),\n};\n\nexport const isValidIcon: CommonTestConfig = {\n  name: 'isValidIcon',\n  message: `\\${path} is not a valid icon name. Make sure your icon name starts with an alphanumeric character and only includes alphanumeric characters or dashes.`,\n  test: (val) => val === '' || ICON_REGEX.test(val as string),\n};\n\nexport const isValidUID: CommonTestConfig = {\n  name: 'isValidUID',\n  message: `\\${path} must match the following regex: ${UID_REGEX}`,\n  test: (val) => val === '' || UID_REGEX.test(val as string),\n};\n\nexport const isValidCategoryName: CommonTestConfig = {\n  name: 'isValidCategoryName',\n  message: `\\${path} must start with a letter and only contain letters, numbers, dashes and underscores`,\n  test: (val) => val === '' || CATEGORY_NAME_REGEX.test(val as string),\n};\n\nexport const isValidCollectionName: CommonTestConfig = {\n  name: 'isValidCollectionName',\n  message: `\\${path} must match the following regex: ${COLLECTION_NAME_REGEX}`,\n  test: (val) => val === '' || COLLECTION_NAME_REGEX.test(val as string),\n};\n\nexport const isValidKey = (key: string): CommonTestConfig => ({\n  name: 'isValidKey',\n  message: `Attribute name '${key}' must match the following regex: ${NAME_REGEX}`,\n  test: () => NAME_REGEX.test(key),\n});\n\nexport const isValidEnum: CommonTestConfig = {\n  name: 'isValidEnum',\n  message: '${path} should not start with number',\n  test: (val) => val === '' || !strings.startsWithANumber(val as string),\n};\n\nexport const areEnumValuesUnique: CommonTestConfig = {\n  name: 'areEnumValuesUnique',\n  message: '${path} cannot contain duplicate values',\n  test(values) {\n    const filtered = [...new Set(values as string[])];\n\n    return filtered.length === (values as string[]).length;\n  },\n};\n\nexport const isValidRegExpPattern: CommonTestConfig = {\n  name: 'isValidRegExpPattern',\n  message: '${path} must be a valid RexExp pattern string',\n  test: (val) => val === '' || !!new RegExp(val as string),\n};\n\nexport const isValidDefaultJSON: CommonTestConfig = {\n  name: 'isValidDefaultJSON',\n  message: '${path} is not a valid JSON',\n  test(val) {\n    if (val === undefined) {\n      return true;\n    }\n\n    if (_.isNumber(val) || _.isNull(val) || _.isObject(val) || _.isArray(val)) {\n      return true;\n    }\n\n    try {\n      JSON.parse(val as string);\n\n      return true;\n    } catch {\n      return false;\n    }\n  },\n};\n"],"names":["validators","required","yup","boolean","unique","minLength","number","integer","positive","maxLength","NAME_REGEX","COLLECTION_NAME_REGEX","CATEGORY_NAME_REGEX","ICON_REGEX","UID_REGEX","KEBAB_BASE_REGEX","CONTENT_TYPE_UID_REGEX","isValidName","name","message","test","val","isValidIcon","isValidCategoryName","isValidCollectionName","isValidKey","key","isValidEnum","strings","startsWithANumber","areEnumValuesUnique","values","filtered","Set","length","isValidRegExpPattern","RegExp","isValidDefaultJSON","undefined","_","isNumber","isNull","isObject","isArray","JSON","parse"],"mappings":"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"}

package/dist/server/controllers/validation/common.mjs

@@ -13,6 +13,8 @@ const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;
 const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;
 const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;
 const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+// Fully-qualified content-type uid: `api::a.a` / `plugin::p.p` / `strapi::x` / `admin::x`.
+const CONTENT_TYPE_UID_REGEX = /^((strapi|admin)::[\w-]+|(api|plugin)::[\w-]+\.[\w-]+)$/;
 const isValidName = {
     name: 'isValidName',
     message: `\${path} must match the following regex: ${NAME_REGEX}`,
@@ -77,5 +79,5 @@ const isValidDefaultJSON = {
     }
 };
 
-export { CATEGORY_NAME_REGEX, COLLECTION_NAME_REGEX, ICON_REGEX, KEBAB_BASE_REGEX, NAME_REGEX, UID_REGEX, areEnumValuesUnique, isValidCategoryName, isValidCollectionName, isValidDefaultJSON, isValidEnum, isValidIcon, isValidKey, isValidName, isValidRegExpPattern, validators };
+export { CATEGORY_NAME_REGEX, COLLECTION_NAME_REGEX, CONTENT_TYPE_UID_REGEX, ICON_REGEX, KEBAB_BASE_REGEX, NAME_REGEX, UID_REGEX, areEnumValuesUnique, isValidCategoryName, isValidCollectionName, isValidDefaultJSON, isValidEnum, isValidIcon, isValidKey, isValidName, isValidRegExpPattern, validators };
 //# sourceMappingURL=common.mjs.map

package/dist/server/controllers/validation/common.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"common.mjs","sources":["../../../../server/src/controllers/validation/common.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string */\nimport { yup, strings } from '@strapi/utils';\nimport _ from 'lodash';\nimport { TestConfig } from 'yup';\n\nexport const validators = {\n  required: yup.boolean(),\n  unique: yup.boolean(),\n  minLength: yup.number().integer().positive(),\n  maxLength: yup.number().integer().positive(),\n};\n\nexport const NAME_REGEX = /^[A-Za-z][_0-9A-Za-z]*$/;\nexport const COLLECTION_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;\nexport const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;\nexport const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\n\nexport type CommonTestConfig = TestConfig<unknown | undefined, Record<string, unknown>>;\n\nexport const isValidName: CommonTestConfig = {\n  name: 'isValidName',\n  message: `\\${path} must match the following regex: ${NAME_REGEX}`,\n  test: (val: unknown) => val === '' || NAME_REGEX.test(val as string),\n};\n\nexport const isValidIcon: CommonTestConfig = {\n  name: 'isValidIcon',\n  message: `\\${path} is not a valid icon name. Make sure your icon name starts with an alphanumeric character and only includes alphanumeric characters or dashes.`,\n  test: (val) => val === '' || ICON_REGEX.test(val as string),\n};\n\nexport const isValidUID: CommonTestConfig = {\n  name: 'isValidUID',\n  message: `\\${path} must match the following regex: ${UID_REGEX}`,\n  test: (val) => val === '' || UID_REGEX.test(val as string),\n};\n\nexport const isValidCategoryName: CommonTestConfig = {\n  name: 'isValidCategoryName',\n  message: `\\${path} must start with a letter and only contain letters, numbers, dashes and underscores`,\n  test: (val) => val === '' || CATEGORY_NAME_REGEX.test(val as string),\n};\n\nexport const isValidCollectionName: CommonTestConfig = {\n  name: 'isValidCollectionName',\n  message: `\\${path} must match the following regex: ${COLLECTION_NAME_REGEX}`,\n  test: (val) => val === '' || COLLECTION_NAME_REGEX.test(val as string),\n};\n\nexport const isValidKey = (key: string): CommonTestConfig => ({\n  name: 'isValidKey',\n  message: `Attribute name '${key}' must match the following regex: ${NAME_REGEX}`,\n  test: () => NAME_REGEX.test(key),\n});\n\nexport const isValidEnum: CommonTestConfig = {\n  name: 'isValidEnum',\n  message: '${path} should not start with number',\n  test: (val) => val === '' || !strings.startsWithANumber(val as string),\n};\n\nexport const areEnumValuesUnique: CommonTestConfig = {\n  name: 'areEnumValuesUnique',\n  message: '${path} cannot contain duplicate values',\n  test(values) {\n    const filtered = [...new Set(values as string[])];\n\n    return filtered.length === (values as string[]).length;\n  },\n};\n\nexport const isValidRegExpPattern: CommonTestConfig = {\n  name: 'isValidRegExpPattern',\n  message: '${path} must be a valid RexExp pattern string',\n  test: (val) => val === '' || !!new RegExp(val as string),\n};\n\nexport const isValidDefaultJSON: CommonTestConfig = {\n  name: 'isValidDefaultJSON',\n  message: '${path} is not a valid JSON',\n  test(val) {\n    if (val === undefined) {\n      return true;\n    }\n\n    if (_.isNumber(val) || _.isNull(val) || _.isObject(val) || _.isArray(val)) {\n      return true;\n    }\n\n    try {\n      JSON.parse(val as string);\n\n      return true;\n    } catch {\n      return false;\n    }\n  },\n};\n"],"names":["validators","required","yup","boolean","unique","minLength","number","integer","positive","maxLength","NAME_REGEX","COLLECTION_NAME_REGEX","CATEGORY_NAME_REGEX","ICON_REGEX","UID_REGEX","KEBAB_BASE_REGEX","isValidName","name","message","test","val","isValidIcon","isValidCategoryName","isValidCollectionName","isValidKey","key","isValidEnum","strings","startsWithANumber","areEnumValuesUnique","values","filtered","Set","length","isValidRegExpPattern","RegExp","isValidDefaultJSON","undefined","_","isNumber","isNull","isObject","isArray","JSON","parse"],"mappings":"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"}
+{"version":3,"file":"common.mjs","sources":["../../../../server/src/controllers/validation/common.ts"],"sourcesContent":["/* eslint-disable no-template-curly-in-string */\nimport { yup, strings } from '@strapi/utils';\nimport _ from 'lodash';\nimport { TestConfig } from 'yup';\n\nexport const validators = {\n  required: yup.boolean(),\n  unique: yup.boolean(),\n  minLength: yup.number().integer().positive(),\n  maxLength: yup.number().integer().positive(),\n};\n\nexport const NAME_REGEX = /^[A-Za-z][_0-9A-Za-z]*$/;\nexport const COLLECTION_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const CATEGORY_NAME_REGEX = /^[A-Za-z][-_0-9A-Za-z]*$/;\nexport const ICON_REGEX = /^[A-Za-z0-9][-A-Za-z0-9]*$/;\nexport const UID_REGEX = /^[A-Za-z0-9-_.~]*$/;\nexport const KEBAB_BASE_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\n// Fully-qualified content-type uid: `api::a.a` / `plugin::p.p` / `strapi::x` / `admin::x`.\nexport const CONTENT_TYPE_UID_REGEX = /^((strapi|admin)::[\\w-]+|(api|plugin)::[\\w-]+\\.[\\w-]+)$/;\n\nexport type CommonTestConfig = TestConfig<unknown | undefined, Record<string, unknown>>;\n\nexport const isValidName: CommonTestConfig = {\n  name: 'isValidName',\n  message: `\\${path} must match the following regex: ${NAME_REGEX}`,\n  test: (val: unknown) => val === '' || NAME_REGEX.test(val as string),\n};\n\nexport const isValidIcon: CommonTestConfig = {\n  name: 'isValidIcon',\n  message: `\\${path} is not a valid icon name. Make sure your icon name starts with an alphanumeric character and only includes alphanumeric characters or dashes.`,\n  test: (val) => val === '' || ICON_REGEX.test(val as string),\n};\n\nexport const isValidUID: CommonTestConfig = {\n  name: 'isValidUID',\n  message: `\\${path} must match the following regex: ${UID_REGEX}`,\n  test: (val) => val === '' || UID_REGEX.test(val as string),\n};\n\nexport const isValidCategoryName: CommonTestConfig = {\n  name: 'isValidCategoryName',\n  message: `\\${path} must start with a letter and only contain letters, numbers, dashes and underscores`,\n  test: (val) => val === '' || CATEGORY_NAME_REGEX.test(val as string),\n};\n\nexport const isValidCollectionName: CommonTestConfig = {\n  name: 'isValidCollectionName',\n  message: `\\${path} must match the following regex: ${COLLECTION_NAME_REGEX}`,\n  test: (val) => val === '' || COLLECTION_NAME_REGEX.test(val as string),\n};\n\nexport const isValidKey = (key: string): CommonTestConfig => ({\n  name: 'isValidKey',\n  message: `Attribute name '${key}' must match the following regex: ${NAME_REGEX}`,\n  test: () => NAME_REGEX.test(key),\n});\n\nexport const isValidEnum: CommonTestConfig = {\n  name: 'isValidEnum',\n  message: '${path} should not start with number',\n  test: (val) => val === '' || !strings.startsWithANumber(val as string),\n};\n\nexport const areEnumValuesUnique: CommonTestConfig = {\n  name: 'areEnumValuesUnique',\n  message: '${path} cannot contain duplicate values',\n  test(values) {\n    const filtered = [...new Set(values as string[])];\n\n    return filtered.length === (values as string[]).length;\n  },\n};\n\nexport const isValidRegExpPattern: CommonTestConfig = {\n  name: 'isValidRegExpPattern',\n  message: '${path} must be a valid RexExp pattern string',\n  test: (val) => val === '' || !!new RegExp(val as string),\n};\n\nexport const isValidDefaultJSON: CommonTestConfig = {\n  name: 'isValidDefaultJSON',\n  message: '${path} is not a valid JSON',\n  test(val) {\n    if (val === undefined) {\n      return true;\n    }\n\n    if (_.isNumber(val) || _.isNull(val) || _.isObject(val) || _.isArray(val)) {\n      return true;\n    }\n\n    try {\n      JSON.parse(val as string);\n\n      return true;\n    } catch {\n      return false;\n    }\n  },\n};\n"],"names":["validators","required","yup","boolean","unique","minLength","number","integer","positive","maxLength","NAME_REGEX","COLLECTION_NAME_REGEX","CATEGORY_NAME_REGEX","ICON_REGEX","UID_REGEX","KEBAB_BASE_REGEX","CONTENT_TYPE_UID_REGEX","isValidName","name","message","test","val","isValidIcon","isValidCategoryName","isValidCollectionName","isValidKey","key","isValidEnum","strings","startsWithANumber","areEnumValuesUnique","values","filtered","Set","length","isValidRegExpPattern","RegExp","isValidDefaultJSON","undefined","_","isNumber","isNull","isObject","isArray","JSON","parse"],"mappings":"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"}

package/dist/server/controllers/validation/content-structure.js

@@ -0,0 +1,177 @@
+'use strict';
+
+var zod = require('zod');
+var common = require('./common.js');
+
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS_REGEX = /[\x00-\x1F\x7F-\x9F]/;
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_REGEX = /\x1B\[[0-9;]*[A-Za-z]/;
+const GROUP_NAME_MAX_LENGTH = 255;
+const groupIdSchema = zod.z.string().min(1, 'Group id must not be empty');
+const groupNameSchema = zod.z.string().min(1, 'Group name must not be empty').max(GROUP_NAME_MAX_LENGTH, `Group name must be at most ${GROUP_NAME_MAX_LENGTH} characters`).refine((value)=>value.trim().length > 0, 'Group name must not be empty').refine((value)=>value === value.trim(), 'Group name must not have leading or trailing whitespace').refine((value)=>!CONTROL_CHARS_REGEX.test(value), 'Group name must not contain control characters').refine((value)=>!ANSI_ESCAPE_REGEX.test(value), 'Group name must not contain ANSI escape characters');
+const contentStructureChildSchema = zod.z.discriminatedUnion('type', [
+    zod.z.object({
+        uid: zod.z.string().regex(common.CONTENT_TYPE_UID_REGEX, 'Invalid content type uid'),
+        type: zod.z.literal('contentType')
+    }),
+    zod.z.object({
+        type: zod.z.literal('group'),
+        id: groupIdSchema
+    })
+]);
+/** Zod schema for a group record */ const contentStructureGroupSchema = zod.z.object({
+    children: zod.z.array(contentStructureChildSchema),
+    parent: groupIdSchema.nullable(),
+    name: groupNameSchema,
+    id: groupIdSchema
+});
+const contentStructureSectionSchema = zod.z.object({
+    groups: zod.z.array(contentStructureGroupSchema)
+});
+const contentStructureFileObjectSchema = zod.z.object({
+    version: zod.z.literal(1),
+    sections: zod.z.object({
+        collectionTypes: contentStructureSectionSchema,
+        singleTypes: contentStructureSectionSchema
+    })
+});
+const MAX_FOLDER_DEPTH = 3;
+/**
+ * File-wide group-id uniqueness across singleTypes and collectionTypes
+ */ const uniqueGroupIdsAcrossFile = (file, ctx)=>{
+    const seen = new Set();
+    for (const section of [
+        file.sections.collectionTypes,
+        file.sections.singleTypes
+    ]){
+        for (const group of section.groups){
+            if (seen.has(group.id)) {
+                ctx.addIssue({
+                    message: `Duplicate group id "${group.id}"`,
+                    code: zod.z.ZodIssueCode.custom,
+                    path: [
+                        'sections'
+                    ]
+                });
+            }
+            seen.add(group.id);
+        }
+    }
+};
+/**
+ * File-internal graph resolution/validation.
+ * This performs all context-UNAWARE validation of the structure. Context-aware validation is performed at the CTB service layer.
+ */ const validateSectionGraph = (groups, sectionKey, ctx)=>{
+    const path = [
+        'sections',
+        sectionKey,
+        'groups'
+    ];
+    const byId = new Map(groups.map((group)=>[
+            group.id,
+            group
+        ]));
+    const report = (message)=>{
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            path,
+            message
+        });
+    };
+    // Sibling group names must be unique within the same parent (case-insensitive).
+    const siblingNames = new Map();
+    for (const group of groups){
+        const name = group.name.trim().toLowerCase();
+        const seen = siblingNames.get(group.parent) ?? new Set();
+        if (seen.has(name)) {
+            const where = group.parent ? `group "${group.parent}"` : 'the section root';
+            report(`Sibling groups under ${where} in section "${sectionKey}" share the name "${group.name.trim()}"`);
+        }
+        seen.add(name);
+        siblingNames.set(group.parent, seen);
+    }
+    // Parent references a group in the SAME section.
+    // No cycles
+    // Depth <= 3
+    for (const group of groups){
+        if (group.parent !== null && !byId.has(group.parent)) {
+            report(`Group "${group.id}" references parent "${group.parent}" which is not a group in section "${sectionKey}"`);
+            continue;
+        }
+        const chain = new Set([
+            group.id
+        ]);
+        let current = group;
+        let depth = 1;
+        let broken = false;
+        while(current && current.parent !== null){
+            if (chain.has(current.parent)) {
+                report(`Group "${group.id}" is part of a parent cycle`);
+                broken = true;
+                break;
+            }
+            const parent = byId.get(current.parent);
+            if (!parent) {
+                broken = true;
+                break;
+            }
+            chain.add(current.parent);
+            current = parent;
+            depth += 1;
+        }
+        if (!broken && depth > MAX_FOLDER_DEPTH) {
+            report(`Group "${group.id}" exceeds the maximum nesting depth of ${MAX_FOLDER_DEPTH} in section "${sectionKey}"`);
+        }
+    }
+    // Group children reference an existing group in the same section whose parent points back at the containing group.
+    // Also, each content type appears in at most ONE group.
+    const groupChildCount = new Map();
+    const seenUids = new Set();
+    for (const group of groups){
+        for (const child of group.children){
+            if (child.type === 'group') {
+                const target = byId.get(child.id);
+                if (!target) {
+                    report(`Group "${group.id}" has a group child "${child.id}" that does not exist in section "${sectionKey}"`);
+                    continue;
+                }
+                if (target.parent !== group.id) {
+                    report(`Group child "${child.id}" of "${group.id}" does not list "${group.id}" as its parent`);
+                }
+                groupChildCount.set(child.id, (groupChildCount.get(child.id) ?? 0) + 1);
+                continue;
+            }
+            if (seenUids.has(child.uid)) {
+                report(`Content type "${child.uid}" appears in more than one group in section "${sectionKey}"`);
+            } else {
+                seenUids.add(child.uid);
+            }
+        }
+    }
+    // Every non-root group should appear exactly once as a group child.
+    for (const group of groups){
+        const count = groupChildCount.get(group.id) ?? 0;
+        if (group.parent === null) {
+            if (count > 0) {
+                report(`Root group "${group.id}" is listed as a group child of another group in section "${sectionKey}"`);
+            }
+            continue;
+        }
+        if (count === 0) {
+            report(`Group "${group.id}" is not listed in the children of its parent "${group.parent}"`);
+        } else if (count > 1) {
+            report(`Group "${group.id}" is listed ${count} times as a group child in section "${sectionKey}"`);
+        }
+    }
+};
+const validateGraphRules = (file, ctx)=>{
+    validateSectionGraph(file.sections.collectionTypes.groups, 'collectionTypes', ctx);
+    validateSectionGraph(file.sections.singleTypes.groups, 'singleTypes', ctx);
+};
+const contentStructureFileSchema = contentStructureFileObjectSchema.superRefine(uniqueGroupIdsAcrossFile).superRefine(validateGraphRules);
+
+exports.contentStructureChildSchema = contentStructureChildSchema;
+exports.contentStructureFileSchema = contentStructureFileSchema;
+exports.contentStructureGroupSchema = contentStructureGroupSchema;
+//# sourceMappingURL=content-structure.js.map

package/dist/server/controllers/validation/content-structure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-structure.js","sources":["../../../../server/src/controllers/validation/content-structure.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { CONTENT_TYPE_UID_REGEX } from './common';\n\n// eslint-disable-next-line no-control-regex\nconst CONTROL_CHARS_REGEX = /[\\x00-\\x1F\\x7F-\\x9F]/;\n// eslint-disable-next-line no-control-regex\nconst ANSI_ESCAPE_REGEX = /\\x1B\\[[0-9;]*[A-Za-z]/;\n\nconst GROUP_NAME_MAX_LENGTH = 255;\n\nconst groupIdSchema = z.string().min(1, 'Group id must not be empty');\n\nconst groupNameSchema = z\n  .string()\n  .min(1, 'Group name must not be empty')\n  .max(GROUP_NAME_MAX_LENGTH, `Group name must be at most ${GROUP_NAME_MAX_LENGTH} characters`)\n  .refine((value) => value.trim().length > 0, 'Group name must not be empty')\n  .refine(\n    (value) => value === value.trim(),\n    'Group name must not have leading or trailing whitespace'\n  )\n  .refine(\n    (value) => !CONTROL_CHARS_REGEX.test(value),\n    'Group name must not contain control characters'\n  )\n  .refine(\n    (value) => !ANSI_ESCAPE_REGEX.test(value),\n    'Group name must not contain ANSI escape characters'\n  );\n\nexport const contentStructureChildSchema = z.discriminatedUnion('type', [\n  z.object({\n    uid: z.string().regex(CONTENT_TYPE_UID_REGEX, 'Invalid content type uid'),\n    type: z.literal('contentType'),\n  }),\n  z.object({\n    type: z.literal('group'),\n    id: groupIdSchema,\n  }),\n]);\n\n/** Zod schema for a group record */\nexport const contentStructureGroupSchema = z.object({\n  children: z.array(contentStructureChildSchema),\n  parent: groupIdSchema.nullable(),\n  name: groupNameSchema,\n  id: groupIdSchema,\n});\n\nconst contentStructureSectionSchema = z.object({\n  groups: z.array(contentStructureGroupSchema),\n});\n\nconst contentStructureFileObjectSchema = z.object({\n  version: z.literal(1),\n  sections: z.object({\n    collectionTypes: contentStructureSectionSchema,\n    singleTypes: contentStructureSectionSchema,\n  }),\n});\n\ntype ContentStructureFileObject = z.infer<typeof contentStructureFileObjectSchema>;\ntype ContentStructureGroupInput = z.infer<typeof contentStructureGroupSchema>;\ntype SuperRefinement<T> = (value: T, ctx: z.RefinementCtx) => void | Promise<void>;\n\nconst MAX_FOLDER_DEPTH = 3;\n\n/**\n * File-wide group-id uniqueness across singleTypes and collectionTypes\n */\nconst uniqueGroupIdsAcrossFile: SuperRefinement<ContentStructureFileObject> = (file, ctx) => {\n  const seen = new Set<string>();\n\n  for (const section of [file.sections.collectionTypes, file.sections.singleTypes]) {\n    for (const group of section.groups) {\n      if (seen.has(group.id)) {\n        ctx.addIssue({\n          message: `Duplicate group id \"${group.id}\"`,\n          code: z.ZodIssueCode.custom,\n          path: ['sections'],\n        });\n      }\n\n      seen.add(group.id);\n    }\n  }\n};\n\n/**\n * File-internal graph resolution/validation.\n * This performs all context-UNAWARE validation of the structure. Context-aware validation is performed at the CTB service layer.\n */\nconst validateSectionGraph = (\n  groups: ContentStructureGroupInput[],\n  sectionKey: 'collectionTypes' | 'singleTypes',\n  ctx: z.RefinementCtx\n) => {\n  const path: (string | number)[] = ['sections', sectionKey, 'groups'];\n  const byId = new Map(groups.map((group) => [group.id, group]));\n\n  const report = (message: string) => {\n    ctx.addIssue({ code: z.ZodIssueCode.custom, path, message });\n  };\n\n  // Sibling group names must be unique within the same parent (case-insensitive).\n  const siblingNames = new Map<string | null, Set<string>>();\n\n  for (const group of groups) {\n    const name = group.name.trim().toLowerCase();\n    const seen = siblingNames.get(group.parent) ?? new Set<string>();\n\n    if (seen.has(name)) {\n      const where = group.parent ? `group \"${group.parent}\"` : 'the section root';\n      report(\n        `Sibling groups under ${where} in section \"${sectionKey}\" share the name \"${group.name.trim()}\"`\n      );\n    }\n\n    seen.add(name);\n    siblingNames.set(group.parent, seen);\n  }\n\n  // Parent references a group in the SAME section.\n  // No cycles\n  // Depth <= 3\n  for (const group of groups) {\n    if (group.parent !== null && !byId.has(group.parent)) {\n      report(\n        `Group \"${group.id}\" references parent \"${group.parent}\" which is not a group in section \"${sectionKey}\"`\n      );\n      continue;\n    }\n\n    const chain = new Set<string>([group.id]);\n\n    let current: ContentStructureGroupInput | undefined = group;\n    let depth = 1;\n    let broken = false;\n\n    while (current && current.parent !== null) {\n      if (chain.has(current.parent)) {\n        report(`Group \"${group.id}\" is part of a parent cycle`);\n        broken = true;\n        break;\n      }\n\n      const parent = byId.get(current.parent);\n\n      if (!parent) {\n        broken = true;\n        break;\n      }\n\n      chain.add(current.parent);\n      current = parent;\n      depth += 1;\n    }\n\n    if (!broken && depth > MAX_FOLDER_DEPTH) {\n      report(\n        `Group \"${group.id}\" exceeds the maximum nesting depth of ${MAX_FOLDER_DEPTH} in section \"${sectionKey}\"`\n      );\n    }\n  }\n\n  // Group children reference an existing group in the same section whose parent points back at the containing group.\n  // Also, each content type appears in at most ONE group.\n  const groupChildCount = new Map<string, number>();\n  const seenUids = new Set<string>();\n\n  for (const group of groups) {\n    for (const child of group.children) {\n      if (child.type === 'group') {\n        const target = byId.get(child.id);\n\n        if (!target) {\n          report(\n            `Group \"${group.id}\" has a group child \"${child.id}\" that does not exist in section \"${sectionKey}\"`\n          );\n          continue;\n        }\n\n        if (target.parent !== group.id) {\n          report(\n            `Group child \"${child.id}\" of \"${group.id}\" does not list \"${group.id}\" as its parent`\n          );\n        }\n\n        groupChildCount.set(child.id, (groupChildCount.get(child.id) ?? 0) + 1);\n        continue;\n      }\n\n      if (seenUids.has(child.uid)) {\n        report(\n          `Content type \"${child.uid}\" appears in more than one group in section \"${sectionKey}\"`\n        );\n      } else {\n        seenUids.add(child.uid);\n      }\n    }\n  }\n\n  // Every non-root group should appear exactly once as a group child.\n  for (const group of groups) {\n    const count = groupChildCount.get(group.id) ?? 0;\n\n    if (group.parent === null) {\n      if (count > 0) {\n        report(\n          `Root group \"${group.id}\" is listed as a group child of another group in section \"${sectionKey}\"`\n        );\n      }\n      continue;\n    }\n\n    if (count === 0) {\n      report(`Group \"${group.id}\" is not listed in the children of its parent \"${group.parent}\"`);\n    } else if (count > 1) {\n      report(\n        `Group \"${group.id}\" is listed ${count} times as a group child in section \"${sectionKey}\"`\n      );\n    }\n  }\n};\n\nconst validateGraphRules: SuperRefinement<ContentStructureFileObject> = (file, ctx) => {\n  validateSectionGraph(file.sections.collectionTypes.groups, 'collectionTypes', ctx);\n  validateSectionGraph(file.sections.singleTypes.groups, 'singleTypes', ctx);\n};\n\nexport const contentStructureFileSchema = contentStructureFileObjectSchema\n  .superRefine(uniqueGroupIdsAcrossFile)\n  .superRefine(validateGraphRules);\n\nexport type ContentStructureFileInput = z.infer<typeof contentStructureFileSchema>;\n"],"names":["CONTROL_CHARS_REGEX","ANSI_ESCAPE_REGEX","GROUP_NAME_MAX_LENGTH","groupIdSchema","z","string","min","groupNameSchema","max","refine","value","trim","length","test","contentStructureChildSchema","discriminatedUnion","object","uid","regex","CONTENT_TYPE_UID_REGEX","type","literal","id","contentStructureGroupSchema","children","array","parent","nullable","name","contentStructureSectionSchema","groups","contentStructureFileObjectSchema","version","sections","collectionTypes","singleTypes","MAX_FOLDER_DEPTH","uniqueGroupIdsAcrossFile","file","ctx","seen","Set","section","group","has","addIssue","message","code","ZodIssueCode","custom","path","add","validateSectionGraph","sectionKey","byId","Map","map","report","siblingNames","toLowerCase","get","where","set","chain","current","depth","broken","groupChildCount","seenUids","child","target","count","validateGraphRules","contentStructureFileSchema","superRefine"],"mappings":"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"}