@strapi/core 0.0.0-experimental.a407f3bc8fb79a53cf7975140864526b6ddbac4b → 0.0.0-experimental.a40985766ab04e433896342630dbc2832adeb389

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

@@ -1 +1 @@
-{"version":3,"file":"transform-content-types-to-models.d.ts","sourceRoot":"","sources":["../../src/utils/transform-content-types-to-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAS,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAMhD;;;;;GAKG;AAEH,eAAO,MAAM,2BAA2B,eAAe,CAAC;AACxD,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,6BAA6B,cAAc,CAAC;AACzD,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AACtD,eAAO,MAAM,MAAM,WAAW,CAAC;AAE/B,eAAO,MAAM,yBAAyB,mBAAoB,MAAM,WACmB,CAAC;AAEpF,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,WACmB,CAAC;AAI7E,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,WAAW,GACrD,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC;AAG7E,eAAO,MAAM,kBAAkB,SACvB,MAAM,aACD,UAAU,GAAG,eACX,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFpC,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBAAiB,sBAAsB,OAOtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBACf,sBAAsB;UACc,aAAa,GAAG,WAAW;CAI7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,iBAAW,CAAC;AA6EzC,eAAO,MAAM,6BAA6B,iBAAkB,sBAAsB,EAAE,KAAG,KAAK,EAiD3F,CAAC"}
+{"version":3,"file":"transform-content-types-to-models.d.ts","sourceRoot":"","sources":["../../src/utils/transform-content-types-to-models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,yBAAyB,mBAAoB,MAAM,eAAe,WAAW,WAKzF,CAAC;AAEF,eAAO,MAAM,kBAAkB,mBAAoB,MAAM,eAAe,WAAW,WAKlF,CAAC;AAEF,eAAO,MAAM,gCAAgC,gBAAiB,WAAW,WAKxE,CAAC;AAEF,eAAO,MAAM,iCAAiC,gBAAiB,WAAW,WAKzE,CAAC;AAEF,eAAO,MAAM,sBAAsB,gBAAiB,WAAW,WAE9D,CAAC;AAEF,eAAO,MAAM,uBAAuB,gBAAiB,MAAM,eAAe,WAAW,WAMpF,CAAC;AAIF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,iBAAiB,GAC3D,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,GAChF,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AAG5B,eAAO,MAAM,kBAAkB,SACvB,MAAM,aACD,OAAO,SAAS,CAAC,YAAY,eAC3B,sBAAsB,eACtB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+FzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,gBACjB,sBAAsB,eACtB,WAAW,OAazB,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBACf,sBAAsB;UACc,aAAa,GAAG,WAAW;CAI7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,iBAAW,CAAC;AAgFzC,eAAO,MAAM,6BAA6B,iBAC1B,sBAAsB,EAAE,eACzB,WAAW,KACvB,KAAK,EAkEP,CAAC"}

package/dist/utils/transform-content-types-to-models.js

@@ -1,234 +1,374 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const database = require("@strapi/database");
-const cuid2 = require("@paralleldrive/cuid2");
-const assert = require("node:assert");
-const _ = require("lodash/fp");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
-const assert__default = /* @__PURE__ */ _interopDefault(assert);
-const ___default = /* @__PURE__ */ _interopDefault(_);
-const { identifiers } = database.utils;
-const COMPONENT_JOIN_TABLE_SUFFIX = "components";
-const DZ_JOIN_TABLE_SUFFIX = "components";
-const COMPONENT_INVERSE_COLUMN_NAME = "component";
-const COMPONENT_TYPE_COLUMN = "component_type";
-const ENTITY = "entity";
-const getComponentJoinTableName = (collectionName) => identifiers.getTableName(collectionName, { suffix: COMPONENT_JOIN_TABLE_SUFFIX });
-const getDzJoinTableName = (collectionName) => identifiers.getTableName(collectionName, { suffix: DZ_JOIN_TABLE_SUFFIX });
-const { ID_COLUMN: id, FIELD_COLUMN: field, ORDER_COLUMN: order } = identifiers;
-const transformAttribute = (name, attribute, contentType) => {
-  switch (attribute.type) {
-    case "media": {
-      return {
-        type: "relation",
-        relation: attribute.multiple === true ? "morphMany" : "morphOne",
-        target: "plugin::upload.file",
-        morphBy: "related"
-      };
-    }
-    case "component": {
-      const joinTableName = getComponentJoinTableName(contentType.collectionName);
-      const joinColumnEntityName = identifiers.getJoinColumnAttributeIdName(ENTITY);
-      const joinColumnInverseName = identifiers.getJoinColumnAttributeIdName(
-        COMPONENT_INVERSE_COLUMN_NAME
-      );
-      return {
-        type: "relation",
-        relation: attribute.repeatable === true ? "oneToMany" : "oneToOne",
-        target: attribute.component,
-        // We need the join table name to be deterministic,
-        // We need to allow passing the join table name as an option
-        joinTable: {
-          name: joinTableName,
-          joinColumn: {
-            name: joinColumnEntityName,
-            referencedColumn: id
-          },
-          inverseJoinColumn: {
-            name: joinColumnInverseName,
-            referencedColumn: id
-          },
-          on: {
-            field: name
-          },
-          orderColumnName: order,
-          orderBy: {
-            order: "asc"
-          },
-          pivotColumns: [joinColumnEntityName, joinColumnInverseName, field, COMPONENT_TYPE_COLUMN]
-        }
-      };
-    }
-    case "dynamiczone": {
-      const joinTableName = getDzJoinTableName(contentType.collectionName);
-      const joinColumnEntityName = identifiers.getJoinColumnAttributeIdName(ENTITY);
-      const joinColumnInverseName = identifiers.getJoinColumnAttributeIdName(
-        COMPONENT_INVERSE_COLUMN_NAME
-      );
-      return {
-        type: "relation",
-        relation: "morphToMany",
-        // TODO: handle restrictions at some point
-        // target: attribute.components,
-        joinTable: {
-          name: joinTableName,
-          joinColumn: {
-            name: joinColumnEntityName,
-            referencedColumn: id
-          },
-          morphColumn: {
-            idColumn: {
-              name: joinColumnInverseName,
-              referencedColumn: id
-            },
-            typeColumn: {
-              name: COMPONENT_TYPE_COLUMN
-            },
-            typeField: "__component"
-          },
-          on: {
-            field: name
-          },
-          orderBy: {
-            order: "asc"
-          },
-          pivotColumns: [joinColumnEntityName, joinColumnInverseName, field, COMPONENT_TYPE_COLUMN]
+'use strict';
+
+var cuid2 = require('@paralleldrive/cuid2');
+var assert = require('node:assert');
+var fp = require('lodash/fp');
+
+/**
+ * Because strapi/database models don't know about things like components or dynamic zones, we use this file to convert them
+ * to a relations format that it recognizes
+ *
+ * Therefore we have to keep an additional set of helpers/extensions to the database naming methods
+ *
+ * IMPORTANT!
+ * If we use short versions of anything, we MUST call getNameFromTokens directly; attempting to shorten them ourselves
+ * prevents the unshortened name map from being filled properly, so for example it will think that the short name
+ * 'collection4f3a_cmps' maps to the unshortened 'collectionname_cmps' rather than 'collectionname_components'
+ * Therefore, we only use the identifiers helpers in cases where we do not do any of our own shortening
+ */ const getComponentJoinTableName = (collectionName, identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: collectionName,
+            compressible: true
+        },
+        {
+            name: 'components',
+            shortName: 'cmps',
+            compressible: false
         }
-      };
-    }
-    default: {
-      return attribute;
-    }
-  }
+    ]);
 };
-const transformAttributes = (contentType) => {
-  return Object.keys(contentType.attributes || {}).reduce((attrs, attrName) => {
-    return {
-      ...attrs,
-      [attrName]: transformAttribute(attrName, contentType.attributes[attrName], contentType)
-    };
-  }, {});
+const getDzJoinTableName = (collectionName, identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: collectionName,
+            compressible: true
+        },
+        {
+            name: 'components',
+            shortName: 'cmps',
+            compressible: false
+        }
+    ]);
 };
-const hasComponentsOrDz = (contentType) => {
-  return Object.values(contentType.attributes || {}).some(
-    ({ type }) => type === "dynamiczone" || type === "component"
-  );
+const getComponentJoinColumnEntityName = (identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: 'entity',
+            compressible: false
+        },
+        {
+            name: 'id',
+            compressible: false
+        }
+    ]);
 };
-const createDocumentId = cuid2.createId;
-const createCompoLinkModel = (contentType) => {
-  const name = getComponentJoinTableName(contentType.collectionName);
-  const entityId = identifiers.getJoinColumnAttributeIdName(ENTITY);
-  const componentId = identifiers.getJoinColumnAttributeIdName(COMPONENT_INVERSE_COLUMN_NAME);
-  const fkIndex = identifiers.getFkIndexName([contentType.collectionName, ENTITY]);
-  return {
-    // TODO: make sure there can't be any conflicts with a prefix
-    singularName: name,
-    uid: name,
-    tableName: name,
-    attributes: {
-      [id]: {
-        type: "increments"
-      },
-      [entityId]: {
-        type: "integer",
-        column: {
-          unsigned: true
+const getComponentJoinColumnInverseName = (identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: 'component',
+            shortName: 'cmp',
+            compressible: false
+        },
+        {
+            name: 'id',
+            compressible: false
         }
-      },
-      [componentId]: {
-        type: "integer",
-        column: {
-          unsigned: true
+    ]);
+};
+const getComponentTypeColumn = (identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: 'component_type',
+            compressible: false
         }
-      },
-      [COMPONENT_TYPE_COLUMN]: {
-        type: "string"
-      },
-      [field]: {
-        type: "string"
-      },
-      [order]: {
-        type: "float",
-        column: {
-          unsigned: true,
-          defaultTo: null
+    ]);
+};
+const getComponentFkIndexName = (contentType, identifiers)=>{
+    return identifiers.getNameFromTokens([
+        {
+            name: contentType,
+            compressible: true
+        },
+        {
+            name: 'entity',
+            compressible: false
+        },
+        {
+            name: 'fk',
+            compressible: false
         }
-      }
-    },
-    indexes: [
-      {
-        name: identifiers.getIndexName([contentType.collectionName, field]),
-        columns: [field]
-      },
-      {
-        name: identifiers.getIndexName([contentType.collectionName, COMPONENT_TYPE_COLUMN]),
-        columns: [COMPONENT_TYPE_COLUMN]
-      },
-      {
-        name: fkIndex,
-        columns: [entityId]
-      },
-      {
-        // NOTE: since we don't include attribute names, we need to be careful not to create another unique index
-        name: identifiers.getUniqueIndexName([contentType.collectionName]),
-        columns: [entityId, componentId, field, COMPONENT_TYPE_COLUMN],
-        type: "unique"
-      }
-    ],
-    foreignKeys: [
-      {
-        name: fkIndex,
-        columns: [entityId],
-        referencedColumns: [id],
-        referencedTable: identifiers.getTableName(contentType.collectionName),
-        onDelete: "CASCADE"
-      }
-    ]
-  };
+    ]);
 };
-const transformContentTypesToModels = (contentTypes) => {
-  const models = [];
-  contentTypes.forEach((contentType) => {
-    assert__default.default(contentType.collectionName, 'Content type "collectionName" is required');
-    assert__default.default(contentType.modelName, 'Content type "modelName" is required');
-    assert__default.default(contentType.uid, 'Content type "uid" is required');
-    const documentIdAttribute = contentType.modelType === "contentType" ? { documentId: { type: "string", default: createDocumentId } } : {};
-    const reservedAttributeNames = ["document_id", id];
-    Object.keys(contentType.attributes || {}).forEach((attributeName) => {
-      const snakeCasedAttributeName = ___default.default.snakeCase(attributeName);
-      if (reservedAttributeNames.includes(snakeCasedAttributeName)) {
-        throw new Error(
-          `The attribute "${attributeName}" is reserved and cannot be used in a model. Please rename "${contentType.modelName}" attribute "${attributeName}" to something else.`
-        );
-      }
-    });
-    if (hasComponentsOrDz(contentType)) {
-      const compoLinkModel = createCompoLinkModel(contentType);
-      models.push(compoLinkModel);
+// Transforms an attribute (particularly for relation types) into the format that strapi/database accepts
+const transformAttribute = (name, attribute, contentType, identifiers)=>{
+    switch(attribute.type){
+        case 'media':
+            {
+                return {
+                    type: 'relation',
+                    relation: attribute.multiple === true ? 'morphMany' : 'morphOne',
+                    target: 'plugin::upload.file',
+                    morphBy: 'related'
+                };
+            }
+        case 'component':
+            {
+                const joinTableName = getComponentJoinTableName(contentType.collectionName, identifiers);
+                const joinColumnEntityName = getComponentJoinColumnEntityName(identifiers);
+                const joinColumnInverseName = getComponentJoinColumnInverseName(identifiers);
+                const compTypeColumn = getComponentTypeColumn(identifiers);
+                return {
+                    type: 'relation',
+                    relation: attribute.repeatable === true ? 'oneToMany' : 'oneToOne',
+                    target: attribute.component,
+                    // We need the join table name to be deterministic,
+                    // We need to allow passing the join table name as an option
+                    joinTable: {
+                        name: joinTableName,
+                        joinColumn: {
+                            name: joinColumnEntityName,
+                            referencedColumn: identifiers.ID_COLUMN
+                        },
+                        inverseJoinColumn: {
+                            name: joinColumnInverseName,
+                            referencedColumn: identifiers.ID_COLUMN
+                        },
+                        on: {
+                            field: name
+                        },
+                        orderColumnName: identifiers.ORDER_COLUMN,
+                        orderBy: {
+                            order: 'asc'
+                        },
+                        pivotColumns: [
+                            joinColumnEntityName,
+                            joinColumnInverseName,
+                            identifiers.FIELD_COLUMN,
+                            compTypeColumn
+                        ]
+                    }
+                };
+            }
+        case 'dynamiczone':
+            {
+                const joinTableName = getDzJoinTableName(contentType.collectionName, identifiers);
+                const joinColumnEntityName = getComponentJoinColumnEntityName(identifiers);
+                const joinColumnInverseName = getComponentJoinColumnInverseName(identifiers);
+                const compTypeColumn = getComponentTypeColumn(identifiers);
+                return {
+                    type: 'relation',
+                    relation: 'morphToMany',
+                    // TODO: handle restrictions at some point
+                    // target: attribute.components,
+                    joinTable: {
+                        name: joinTableName,
+                        joinColumn: {
+                            name: joinColumnEntityName,
+                            referencedColumn: identifiers.ID_COLUMN
+                        },
+                        morphColumn: {
+                            idColumn: {
+                                name: joinColumnInverseName,
+                                referencedColumn: identifiers.ID_COLUMN
+                            },
+                            typeColumn: {
+                                name: compTypeColumn
+                            },
+                            typeField: '__component'
+                        },
+                        on: {
+                            field: name
+                        },
+                        orderBy: {
+                            order: 'asc'
+                        },
+                        pivotColumns: [
+                            joinColumnEntityName,
+                            joinColumnInverseName,
+                            identifiers.FIELD_COLUMN,
+                            compTypeColumn
+                        ]
+                    }
+                };
+            }
+        default:
+            {
+                return attribute;
+            }
     }
-    const model = {
-      uid: contentType.uid,
-      singularName: contentType.modelName,
-      tableName: identifiers.getTableName(contentType.collectionName),
-      attributes: {
-        [id]: {
-          type: "increments"
+};
+const transformAttributes = (contentType, identifiers)=>{
+    return Object.keys(contentType.attributes || {}).reduce((attrs, attrName)=>{
+        return {
+            ...attrs,
+            [attrName]: transformAttribute(attrName, contentType.attributes[attrName], contentType, identifiers)
+        };
+    }, {});
+};
+const hasComponentsOrDz = (contentType)=>{
+    return Object.values(contentType.attributes || {}).some(({ type })=>type === 'dynamiczone' || type === 'component');
+};
+const createDocumentId = cuid2.createId;
+const createCompoLinkModel = (contentType, identifiers)=>{
+    const name = getComponentJoinTableName(contentType.collectionName, identifiers);
+    const entityId = getComponentJoinColumnEntityName(identifiers);
+    const componentId = getComponentJoinColumnInverseName(identifiers);
+    const compTypeColumn = getComponentTypeColumn(identifiers);
+    const fkIndex = getComponentFkIndexName(contentType.collectionName, identifiers);
+    return {
+        // TODO: make sure there can't be any conflicts with a prefix
+        singularName: name,
+        uid: name,
+        tableName: name,
+        attributes: {
+            [identifiers.ID_COLUMN]: {
+                type: 'increments'
+            },
+            [entityId]: {
+                type: 'integer',
+                column: {
+                    unsigned: true
+                }
+            },
+            [componentId]: {
+                type: 'integer',
+                column: {
+                    unsigned: true
+                }
+            },
+            [compTypeColumn]: {
+                type: 'string'
+            },
+            [identifiers.FIELD_COLUMN]: {
+                type: 'string'
+            },
+            [identifiers.ORDER_COLUMN]: {
+                type: 'float',
+                column: {
+                    unsigned: true,
+                    defaultTo: null
+                }
+            }
         },
-        ...documentIdAttribute,
-        ...transformAttributes(contentType)
-      }
+        indexes: [
+            {
+                name: identifiers.getIndexName([
+                    contentType.collectionName,
+                    identifiers.FIELD_COLUMN
+                ]),
+                columns: [
+                    identifiers.FIELD_COLUMN
+                ]
+            },
+            {
+                name: identifiers.getIndexName([
+                    contentType.collectionName,
+                    compTypeColumn
+                ]),
+                columns: [
+                    compTypeColumn
+                ]
+            },
+            {
+                name: fkIndex,
+                columns: [
+                    entityId
+                ]
+            },
+            {
+                // NOTE: since we don't include attribute names, we need to be careful not to create another unique index
+                name: identifiers.getUniqueIndexName([
+                    contentType.collectionName
+                ]),
+                columns: [
+                    entityId,
+                    componentId,
+                    identifiers.FIELD_COLUMN,
+                    compTypeColumn
+                ],
+                type: 'unique'
+            }
+        ],
+        foreignKeys: [
+            {
+                name: fkIndex,
+                columns: [
+                    entityId
+                ],
+                referencedColumns: [
+                    identifiers.ID_COLUMN
+                ],
+                referencedTable: identifiers.getTableName(contentType.collectionName),
+                onDelete: 'CASCADE'
+            }
+        ]
     };
-    models.push(model);
-  });
-  return models;
 };
-exports.COMPONENT_INVERSE_COLUMN_NAME = COMPONENT_INVERSE_COLUMN_NAME;
-exports.COMPONENT_JOIN_TABLE_SUFFIX = COMPONENT_JOIN_TABLE_SUFFIX;
-exports.COMPONENT_TYPE_COLUMN = COMPONENT_TYPE_COLUMN;
-exports.DZ_JOIN_TABLE_SUFFIX = DZ_JOIN_TABLE_SUFFIX;
-exports.ENTITY = ENTITY;
+const transformContentTypesToModels = (contentTypes, identifiers)=>{
+    const models = [];
+    contentTypes.forEach((contentType)=>{
+        assert(contentType.collectionName, 'Content type "collectionName" is required');
+        assert(contentType.modelName, 'Content type "modelName" is required');
+        assert(contentType.uid, 'Content type "uid" is required');
+        // Add document id to content types
+        // as it is not documented
+        const documentIdAttribute = contentType.modelType === 'contentType' ? {
+            documentId: {
+                type: 'string',
+                default: createDocumentId
+            }
+        } : {};
+        // TODO: this needs to be combined with getReservedNames, we should not be maintaining two lists
+        // Prevent user from creating a documentId attribute
+        const reservedAttributeNames = [
+            'document_id',
+            identifiers.ID_COLUMN
+        ];
+        Object.keys(contentType.attributes || {}).forEach((attributeName)=>{
+            const snakeCasedAttributeName = fp.snakeCase(attributeName);
+            if (reservedAttributeNames.includes(snakeCasedAttributeName)) {
+                throw new Error(`The attribute "${attributeName}" is reserved and cannot be used in a model. Please rename "${contentType.modelName}" attribute "${attributeName}" to something else.`);
+            }
+        });
+        if (hasComponentsOrDz(contentType)) {
+            const compoLinkModel = createCompoLinkModel(contentType, identifiers);
+            models.push(compoLinkModel);
+        }
+        const model = {
+            uid: contentType.uid,
+            singularName: contentType.modelName,
+            tableName: contentType.collectionName,
+            attributes: {
+                [identifiers.ID_COLUMN]: {
+                    type: 'increments'
+                },
+                ...documentIdAttribute,
+                ...transformAttributes(contentType, identifiers)
+            },
+            indexes: contentType.indexes,
+            foreignKeys: contentType.foreignKeys,
+            lifecycles: contentType?.lifecycles ?? {}
+        };
+        // Add indexes to model
+        if (contentType.modelType === 'contentType') {
+            model.indexes = [
+                ...model.indexes || [],
+                {
+                    name: identifiers.getIndexName([
+                        contentType.collectionName,
+                        'documents'
+                    ]),
+                    // Filter attributes that are not in the schema
+                    columns: [
+                        'documentId',
+                        'locale',
+                        'publishedAt'
+                    ].filter((n)=>model.attributes[n]).map((name)=>identifiers.getColumnName(fp.snakeCase(name)))
+                }
+            ];
+        }
+        models.push(model);
+    });
+    return models;
+};
+
 exports.createDocumentId = createDocumentId;
+exports.getComponentFkIndexName = getComponentFkIndexName;
+exports.getComponentJoinColumnEntityName = getComponentJoinColumnEntityName;
+exports.getComponentJoinColumnInverseName = getComponentJoinColumnInverseName;
 exports.getComponentJoinTableName = getComponentJoinTableName;
+exports.getComponentTypeColumn = getComponentTypeColumn;
 exports.getDzJoinTableName = getDzJoinTableName;
 exports.hasComponentsOrDz = hasComponentsOrDz;
 exports.transformAttribute = transformAttribute;