@strapi/database 5.12.1 → 5.12.3

package/dist/schema/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../src/schema/index.ts"],"sourcesContent":["import createDebug from 'debug';\n\nimport createSchemaBuilder from './builder';\nimport createSchemaDiff from './diff';\nimport createSchemaStorage from './storage';\nimport { metadataToSchema } from './schema';\n\nimport type { Schema, SchemaDiff } from './types';\nimport type { Database } from '..';\n\nexport type * from './types';\n\nconst debug = createDebug('strapi::database');\n\nexport interface SchemaProvider {\n  builder: ReturnType<typeof createSchemaBuilder>;\n  schemaDiff: ReturnType<typeof createSchemaDiff>;\n  schemaStorage: ReturnType<typeof createSchemaStorage>;\n  sync(): Promise<SchemaDiff['status']>;\n  syncSchema(): Promise<SchemaDiff['status']>;\n  reset(): Promise<void>;\n  create(): Promise<void>;\n  drop(): Promise<void>;\n  schema: Schema;\n}\n\ninterface State {\n  schema?: Schema;\n}\n\nexport const createSchemaProvider = (db: Database): SchemaProvider => {\n  const state: State = {};\n\n  return {\n    get schema() {\n      if (!state.schema) {\n        debug('Converting metadata to database schema');\n        state.schema = metadataToSchema(db.metadata);\n      }\n\n      return state.schema;\n    },\n    builder: createSchemaBuilder(db),\n    schemaDiff: createSchemaDiff(db),\n    schemaStorage: createSchemaStorage(db),\n\n    /**\n     * Drops the database schema\n     */\n    async drop() {\n      debug('Dropping database schema');\n\n      const DBSchema = await db.dialect.schemaInspector.getSchema();\n      await this.builder.dropSchema(DBSchema);\n    },\n\n    /**\n     * Creates the database schema\n     */\n    async create() {\n      debug('Created database schema');\n      await this.builder.createSchema(this.schema);\n    },\n\n    /**\n     * Resets the database schema\n     */\n    async reset() {\n      debug('Resetting database schema');\n      await this.drop();\n      await this.create();\n    },\n\n    async syncSchema(): Promise<SchemaDiff['status']> {\n      debug('Synchronizing database schema');\n\n      const databaseSchema = await db.dialect.schemaInspector.getSchema();\n      const storedSchema = await this.schemaStorage.read();\n\n      /*\n        3way diff - DB schema / previous metadataSchema / new metadataSchema\n\n        - When something doesn't exist in the previous metadataSchema -> It's not tracked by us and should be ignored\n        - If no previous metadataSchema => use new metadataSchema so we start tracking them and ignore everything else\n        - Apply this logic to Tables / Columns / Indexes / FKs ...\n        - Handle errors (indexes or fks on incompatible stuff ...)\n\n      */\n\n      const { status, diff } = await this.schemaDiff.diff({\n        previousSchema: storedSchema?.schema,\n        databaseSchema,\n        userSchema: this.schema,\n      });\n\n      if (status === 'CHANGED') {\n        await this.builder.updateSchema(diff);\n      }\n\n      await this.schemaStorage.add(this.schema);\n\n      return status;\n    },\n\n    // TODO: support options to migrate softly or forcefully\n    // TODO: support option to disable auto migration & run a CLI command instead to avoid doing it at startup\n    // TODO: Allow keeping extra indexes / extra tables / extra columns (globally or on a per table basis)\n    async sync(): Promise<SchemaDiff['status']> {\n      if (await db.migrations.shouldRun()) {\n        debug('Found migrations to run');\n        await db.migrations.up();\n\n        return this.syncSchema();\n      }\n\n      const oldSchema = await this.schemaStorage.read();\n\n      if (!oldSchema) {\n        debug('Schema not persisted yet');\n        return this.syncSchema();\n      }\n\n      const { hash: oldHash } = oldSchema;\n      const hash = await this.schemaStorage.hashSchema(this.schema);\n\n      if (oldHash !== hash) {\n        debug('Schema changed');\n\n        return this.syncSchema();\n      }\n\n      debug('Schema unchanged');\n\n      return 'UNCHANGED';\n    },\n  };\n};\n"],"names":["debug","createDebug","createSchemaProvider","db","state","schema","metadataToSchema","metadata","builder","createSchemaBuilder","schemaDiff","createSchemaDiff","schemaStorage","createSchemaStorage","drop","DBSchema","dialect","schemaInspector","getSchema","dropSchema","create","createSchema","reset","syncSchema","databaseSchema","storedSchema","read","status","diff","previousSchema","userSchema","updateSchema","add","sync","migrations","shouldRun","up","oldSchema","hash","oldHash","hashSchema"],"mappings":"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"}

package/dist/schema/schema.js

@@ -0,0 +1,266 @@
+'use strict';
+
+var types = require('../utils/types.js');
+var index = require('../utils/identifiers/index.js');
+
+/**
+ * TODO: This needs to be refactored to support incoming names such as
+ * (column, table, index) that are of the form string | NameToken[] so
+ * that pieces can be passed through and shortened here.
+ *
+ * Currently, we are potentially shortening twice, although in reality
+ * that won't happen since the shortened attribute column names will
+ * fit here because they are already shortened to the max identifier
+ * length
+ *
+ * That is the reason we use getName() here and not getColumnName();
+ * we just want the exact shortened name for the value without doing
+ * any other potential manipulation to it
+ * */ const createColumn = (name, attribute)=>{
+    const { type, args = [], ...opts } = getColumnType(attribute);
+    return {
+        name: index.identifiers.getName(name),
+        type,
+        args,
+        defaultTo: null,
+        notNullable: false,
+        unsigned: false,
+        ...opts,
+        ...'column' in attribute ? attribute.column ?? {} : {}
+    };
+};
+const createTable = (meta)=>{
+    const table = {
+        name: meta.tableName,
+        indexes: meta.indexes || [],
+        foreignKeys: meta.foreignKeys || [],
+        columns: []
+    };
+    for (const key of Object.keys(meta.attributes)){
+        const attribute = meta.attributes[key];
+        // if (types.isRelation(attribute.type)) {
+        if (attribute.type === 'relation') {
+            if ('morphColumn' in attribute && attribute.morphColumn && attribute.owner) {
+                const { idColumn, typeColumn } = attribute.morphColumn;
+                const idColumnName = index.identifiers.getName(idColumn.name);
+                const typeColumnName = index.identifiers.getName(typeColumn.name);
+                table.columns.push(createColumn(idColumnName, {
+                    type: 'integer',
+                    column: {
+                        unsigned: true
+                    }
+                }));
+                table.columns.push(createColumn(typeColumnName, {
+                    type: 'string'
+                }));
+            } else if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner && attribute.joinColumn.referencedTable) {
+                // NOTE: we could pass uniquness for oneToOne to avoid creating more than one to one
+                const { name: columnNameFull, referencedColumn, referencedTable, columnType = 'integer' } = attribute.joinColumn;
+                const columnName = index.identifiers.getName(columnNameFull);
+                const column = createColumn(columnName, {
+                    // TODO: find the column type automatically, or allow passing all the column params
+                    type: columnType,
+                    column: {
+                        unsigned: true
+                    }
+                });
+                table.columns.push(column);
+                const fkName = index.identifiers.getFkIndexName([
+                    table.name,
+                    columnName
+                ]);
+                table.foreignKeys.push({
+                    name: fkName,
+                    columns: [
+                        column.name
+                    ],
+                    referencedTable,
+                    referencedColumns: [
+                        referencedColumn
+                    ],
+                    // NOTE: could allow configuration
+                    onDelete: 'SET NULL'
+                });
+                table.indexes.push({
+                    name: fkName,
+                    columns: [
+                        column.name
+                    ]
+                });
+            }
+        } else if (types.isScalarAttribute(attribute)) {
+            const columnName = index.identifiers.getName(attribute.columnName || key);
+            const column = createColumn(columnName, attribute);
+            if (column.unique) {
+                table.indexes.push({
+                    type: 'unique',
+                    name: index.identifiers.getUniqueIndexName([
+                        table.name,
+                        column.name
+                    ]),
+                    columns: [
+                        columnName
+                    ]
+                });
+            }
+            if (column.primary) {
+                table.indexes.push({
+                    type: 'primary',
+                    name: index.identifiers.getPrimaryIndexName([
+                        table.name,
+                        column.name
+                    ]),
+                    columns: [
+                        columnName
+                    ]
+                });
+            }
+            table.columns.push(column);
+        }
+    }
+    return table;
+};
+const getColumnType = (attribute)=>{
+    if ('columnType' in attribute && attribute.columnType) {
+        return attribute.columnType;
+    }
+    switch(attribute.type){
+        case 'increments':
+            {
+                return {
+                    type: 'increments',
+                    args: [
+                        {
+                            primary: true,
+                            primaryKey: true
+                        }
+                    ],
+                    notNullable: true
+                };
+            }
+        // We might want to convert email/password to string types before going into the orm with specific validators & transformers
+        case 'password':
+        case 'email':
+        case 'string':
+        case 'enumeration':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'uid':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'richtext':
+        case 'text':
+            {
+                return {
+                    type: 'text',
+                    args: [
+                        'longtext'
+                    ]
+                };
+            }
+        case 'blocks':
+        case 'json':
+            {
+                return {
+                    type: 'jsonb'
+                };
+            }
+        case 'integer':
+            {
+                return {
+                    type: 'integer'
+                };
+            }
+        case 'biginteger':
+            {
+                return {
+                    type: 'bigInteger'
+                };
+            }
+        case 'float':
+            {
+                return {
+                    type: 'double'
+                };
+            }
+        case 'decimal':
+            {
+                return {
+                    type: 'decimal',
+                    args: [
+                        10,
+                        2
+                    ]
+                };
+            }
+        case 'date':
+            {
+                return {
+                    type: 'date'
+                };
+            }
+        case 'time':
+            {
+                return {
+                    type: 'time',
+                    args: [
+                        {
+                            precision: 3
+                        }
+                    ]
+                };
+            }
+        case 'datetime':
+            {
+                return {
+                    type: 'datetime',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'timestamp':
+            {
+                return {
+                    type: 'timestamp',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'boolean':
+            {
+                return {
+                    type: 'boolean'
+                };
+            }
+        default:
+            {
+                throw new Error(`Unknown type ${attribute.type}`);
+            }
+    }
+};
+const metadataToSchema = (metadata)=>{
+    const schema = {
+        tables: []
+    };
+    metadata.forEach((metadata)=>{
+        schema.tables.push(createTable(metadata));
+    });
+    return schema;
+};
+
+exports.metadataToSchema = metadataToSchema;
+//# sourceMappingURL=schema.js.map

package/dist/schema/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sources":["../../src/schema/schema.ts"],"sourcesContent":["import * as types from '../utils/types';\nimport { identifiers } from '../utils/identifiers';\nimport type { Metadata, Meta } from '../metadata';\nimport type { Column, Schema, Table } from './types';\nimport type { Attribute } from '../types';\n\n/**\n * TODO: This needs to be refactored to support incoming names such as\n * (column, table, index) that are of the form string | NameToken[] so\n * that pieces can be passed through and shortened here.\n *\n * Currently, we are potentially shortening twice, although in reality\n * that won't happen since the shortened attribute column names will\n * fit here because they are already shortened to the max identifier\n * length\n *\n * That is the reason we use getName() here and not getColumnName();\n * we just want the exact shortened name for the value without doing\n * any other potential manipulation to it\n * */\n\nconst createColumn = (name: string, attribute: Attribute): Column => {\n  const { type, args = [], ...opts } = getColumnType(attribute);\n\n  return {\n    name: identifiers.getName(name),\n    type,\n    args,\n    defaultTo: null,\n    notNullable: false,\n    unsigned: false,\n    ...opts,\n    ...('column' in attribute ? (attribute.column ?? {}) : {}),\n  };\n};\n\nconst createTable = (meta: Meta): Table => {\n  const table: Table = {\n    name: meta.tableName,\n    indexes: meta.indexes || [],\n    foreignKeys: meta.foreignKeys || [],\n    columns: [],\n  };\n\n  for (const key of Object.keys(meta.attributes)) {\n    const attribute = meta.attributes[key];\n\n    // if (types.isRelation(attribute.type)) {\n    if (attribute.type === 'relation') {\n      if ('morphColumn' in attribute && attribute.morphColumn && attribute.owner) {\n        const { idColumn, typeColumn } = attribute.morphColumn;\n\n        const idColumnName = identifiers.getName(idColumn.name);\n        const typeColumnName = identifiers.getName(typeColumn.name);\n\n        table.columns.push(\n          createColumn(idColumnName, {\n            type: 'integer',\n            column: {\n              unsigned: true,\n            },\n          })\n        );\n\n        table.columns.push(createColumn(typeColumnName, { type: 'string' }));\n      } else if (\n        'joinColumn' in attribute &&\n        attribute.joinColumn &&\n        attribute.owner &&\n        attribute.joinColumn.referencedTable\n      ) {\n        // NOTE: we could pass uniquness for oneToOne to avoid creating more than one to one\n\n        const {\n          name: columnNameFull,\n          referencedColumn,\n          referencedTable,\n          columnType = 'integer',\n        } = attribute.joinColumn;\n\n        const columnName = identifiers.getName(columnNameFull);\n\n        const column = createColumn(columnName, {\n          // TODO: find the column type automatically, or allow passing all the column params\n          type: columnType,\n          column: {\n            unsigned: true,\n          },\n        });\n\n        table.columns.push(column);\n\n        const fkName = identifiers.getFkIndexName([table.name, columnName]);\n        table.foreignKeys.push({\n          name: fkName,\n          columns: [column.name],\n          referencedTable,\n          referencedColumns: [referencedColumn],\n          // NOTE: could allow configuration\n          onDelete: 'SET NULL',\n        });\n\n        table.indexes.push({\n          name: fkName,\n          columns: [column.name],\n        });\n      }\n    } else if (types.isScalarAttribute(attribute)) {\n      const columnName = identifiers.getName(attribute.columnName || key);\n\n      const column = createColumn(columnName, attribute);\n\n      if (column.unique) {\n        table.indexes.push({\n          type: 'unique',\n          name: identifiers.getUniqueIndexName([table.name, column.name]),\n          columns: [columnName],\n        });\n      }\n\n      if (column.primary) {\n        table.indexes.push({\n          type: 'primary',\n          name: identifiers.getPrimaryIndexName([table.name, column.name]),\n          columns: [columnName],\n        });\n      }\n\n      table.columns.push(column);\n    }\n  }\n\n  return table;\n};\n\nconst getColumnType = (attribute: Attribute) => {\n  if ('columnType' in attribute && attribute.columnType) {\n    return attribute.columnType;\n  }\n\n  switch (attribute.type) {\n    case 'increments': {\n      return {\n        type: 'increments',\n        args: [{ primary: true, primaryKey: true }],\n        notNullable: true,\n      };\n    }\n\n    // We might want to convert email/password to string types before going into the orm with specific validators & transformers\n    case 'password':\n    case 'email':\n    case 'string':\n    case 'enumeration': {\n      return { type: 'string' };\n    }\n    case 'uid': {\n      return {\n        type: 'string',\n      };\n    }\n    case 'richtext':\n    case 'text': {\n      return {\n        type: 'text',\n        args: ['longtext'],\n      };\n    }\n    case 'blocks':\n    case 'json': {\n      return { type: 'jsonb' };\n    }\n    case 'integer': {\n      return { type: 'integer' };\n    }\n    case 'biginteger': {\n      return { type: 'bigInteger' };\n    }\n    case 'float': {\n      return { type: 'double' };\n    }\n    case 'decimal': {\n      return { type: 'decimal', args: [10, 2] };\n    }\n    case 'date': {\n      return { type: 'date' };\n    }\n    case 'time': {\n      return { type: 'time', args: [{ precision: 3 }] };\n    }\n    case 'datetime': {\n      return {\n        type: 'datetime',\n        args: [\n          {\n            useTz: false,\n            precision: 6,\n          },\n        ],\n      };\n    }\n    case 'timestamp': {\n      return {\n        type: 'timestamp',\n        args: [\n          {\n            useTz: false,\n            precision: 6,\n          },\n        ],\n      };\n    }\n    case 'boolean': {\n      return { type: 'boolean' };\n    }\n    default: {\n      throw new Error(`Unknown type ${attribute.type}`);\n    }\n  }\n};\n\nexport const metadataToSchema = (metadata: Metadata): Schema => {\n  const schema: Schema = {\n    tables: [],\n  };\n\n  metadata.forEach((metadata) => {\n    schema.tables.push(createTable(metadata));\n  });\n\n  return schema;\n};\n"],"names":["createColumn","name","attribute","type","args","opts","getColumnType","identifiers","getName","defaultTo","notNullable","unsigned","column","createTable","meta","table","tableName","indexes","foreignKeys","columns","key","Object","keys","attributes","morphColumn","owner","idColumn","typeColumn","idColumnName","typeColumnName","push","joinColumn","referencedTable","columnNameFull","referencedColumn","columnType","columnName","fkName","getFkIndexName","referencedColumns","onDelete","types","unique","getUniqueIndexName","primary","getPrimaryIndexName","primaryKey","precision","useTz","Error","metadataToSchema","metadata","schema","tables","forEach"],"mappings":"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"}

package/dist/schema/schema.mjs

@@ -0,0 +1,264 @@
+import { isScalarAttribute } from '../utils/types.mjs';
+import { identifiers } from '../utils/identifiers/index.mjs';
+
+/**
+ * TODO: This needs to be refactored to support incoming names such as
+ * (column, table, index) that are of the form string | NameToken[] so
+ * that pieces can be passed through and shortened here.
+ *
+ * Currently, we are potentially shortening twice, although in reality
+ * that won't happen since the shortened attribute column names will
+ * fit here because they are already shortened to the max identifier
+ * length
+ *
+ * That is the reason we use getName() here and not getColumnName();
+ * we just want the exact shortened name for the value without doing
+ * any other potential manipulation to it
+ * */ const createColumn = (name, attribute)=>{
+    const { type, args = [], ...opts } = getColumnType(attribute);
+    return {
+        name: identifiers.getName(name),
+        type,
+        args,
+        defaultTo: null,
+        notNullable: false,
+        unsigned: false,
+        ...opts,
+        ...'column' in attribute ? attribute.column ?? {} : {}
+    };
+};
+const createTable = (meta)=>{
+    const table = {
+        name: meta.tableName,
+        indexes: meta.indexes || [],
+        foreignKeys: meta.foreignKeys || [],
+        columns: []
+    };
+    for (const key of Object.keys(meta.attributes)){
+        const attribute = meta.attributes[key];
+        // if (types.isRelation(attribute.type)) {
+        if (attribute.type === 'relation') {
+            if ('morphColumn' in attribute && attribute.morphColumn && attribute.owner) {
+                const { idColumn, typeColumn } = attribute.morphColumn;
+                const idColumnName = identifiers.getName(idColumn.name);
+                const typeColumnName = identifiers.getName(typeColumn.name);
+                table.columns.push(createColumn(idColumnName, {
+                    type: 'integer',
+                    column: {
+                        unsigned: true
+                    }
+                }));
+                table.columns.push(createColumn(typeColumnName, {
+                    type: 'string'
+                }));
+            } else if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner && attribute.joinColumn.referencedTable) {
+                // NOTE: we could pass uniquness for oneToOne to avoid creating more than one to one
+                const { name: columnNameFull, referencedColumn, referencedTable, columnType = 'integer' } = attribute.joinColumn;
+                const columnName = identifiers.getName(columnNameFull);
+                const column = createColumn(columnName, {
+                    // TODO: find the column type automatically, or allow passing all the column params
+                    type: columnType,
+                    column: {
+                        unsigned: true
+                    }
+                });
+                table.columns.push(column);
+                const fkName = identifiers.getFkIndexName([
+                    table.name,
+                    columnName
+                ]);
+                table.foreignKeys.push({
+                    name: fkName,
+                    columns: [
+                        column.name
+                    ],
+                    referencedTable,
+                    referencedColumns: [
+                        referencedColumn
+                    ],
+                    // NOTE: could allow configuration
+                    onDelete: 'SET NULL'
+                });
+                table.indexes.push({
+                    name: fkName,
+                    columns: [
+                        column.name
+                    ]
+                });
+            }
+        } else if (isScalarAttribute(attribute)) {
+            const columnName = identifiers.getName(attribute.columnName || key);
+            const column = createColumn(columnName, attribute);
+            if (column.unique) {
+                table.indexes.push({
+                    type: 'unique',
+                    name: identifiers.getUniqueIndexName([
+                        table.name,
+                        column.name
+                    ]),
+                    columns: [
+                        columnName
+                    ]
+                });
+            }
+            if (column.primary) {
+                table.indexes.push({
+                    type: 'primary',
+                    name: identifiers.getPrimaryIndexName([
+                        table.name,
+                        column.name
+                    ]),
+                    columns: [
+                        columnName
+                    ]
+                });
+            }
+            table.columns.push(column);
+        }
+    }
+    return table;
+};
+const getColumnType = (attribute)=>{
+    if ('columnType' in attribute && attribute.columnType) {
+        return attribute.columnType;
+    }
+    switch(attribute.type){
+        case 'increments':
+            {
+                return {
+                    type: 'increments',
+                    args: [
+                        {
+                            primary: true,
+                            primaryKey: true
+                        }
+                    ],
+                    notNullable: true
+                };
+            }
+        // We might want to convert email/password to string types before going into the orm with specific validators & transformers
+        case 'password':
+        case 'email':
+        case 'string':
+        case 'enumeration':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'uid':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'richtext':
+        case 'text':
+            {
+                return {
+                    type: 'text',
+                    args: [
+                        'longtext'
+                    ]
+                };
+            }
+        case 'blocks':
+        case 'json':
+            {
+                return {
+                    type: 'jsonb'
+                };
+            }
+        case 'integer':
+            {
+                return {
+                    type: 'integer'
+                };
+            }
+        case 'biginteger':
+            {
+                return {
+                    type: 'bigInteger'
+                };
+            }
+        case 'float':
+            {
+                return {
+                    type: 'double'
+                };
+            }
+        case 'decimal':
+            {
+                return {
+                    type: 'decimal',
+                    args: [
+                        10,
+                        2
+                    ]
+                };
+            }
+        case 'date':
+            {
+                return {
+                    type: 'date'
+                };
+            }
+        case 'time':
+            {
+                return {
+                    type: 'time',
+                    args: [
+                        {
+                            precision: 3
+                        }
+                    ]
+                };
+            }
+        case 'datetime':
+            {
+                return {
+                    type: 'datetime',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'timestamp':
+            {
+                return {
+                    type: 'timestamp',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'boolean':
+            {
+                return {
+                    type: 'boolean'
+                };
+            }
+        default:
+            {
+                throw new Error(`Unknown type ${attribute.type}`);
+            }
+    }
+};
+const metadataToSchema = (metadata)=>{
+    const schema = {
+        tables: []
+    };
+    metadata.forEach((metadata)=>{
+        schema.tables.push(createTable(metadata));
+    });
+    return schema;
+};
+
+export { metadataToSchema };
+//# sourceMappingURL=schema.mjs.map

package/dist/schema/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","sources":["../../src/schema/schema.ts"],"sourcesContent":["import * as types from '../utils/types';\nimport { identifiers } from '../utils/identifiers';\nimport type { Metadata, Meta } from '../metadata';\nimport type { Column, Schema, Table } from './types';\nimport type { Attribute } from '../types';\n\n/**\n * TODO: This needs to be refactored to support incoming names such as\n * (column, table, index) that are of the form string | NameToken[] so\n * that pieces can be passed through and shortened here.\n *\n * Currently, we are potentially shortening twice, although in reality\n * that won't happen since the shortened attribute column names will\n * fit here because they are already shortened to the max identifier\n * length\n *\n * That is the reason we use getName() here and not getColumnName();\n * we just want the exact shortened name for the value without doing\n * any other potential manipulation to it\n * */\n\nconst createColumn = (name: string, attribute: Attribute): Column => {\n  const { type, args = [], ...opts } = getColumnType(attribute);\n\n  return {\n    name: identifiers.getName(name),\n    type,\n    args,\n    defaultTo: null,\n    notNullable: false,\n    unsigned: false,\n    ...opts,\n    ...('column' in attribute ? (attribute.column ?? {}) : {}),\n  };\n};\n\nconst createTable = (meta: Meta): Table => {\n  const table: Table = {\n    name: meta.tableName,\n    indexes: meta.indexes || [],\n    foreignKeys: meta.foreignKeys || [],\n    columns: [],\n  };\n\n  for (const key of Object.keys(meta.attributes)) {\n    const attribute = meta.attributes[key];\n\n    // if (types.isRelation(attribute.type)) {\n    if (attribute.type === 'relation') {\n      if ('morphColumn' in attribute && attribute.morphColumn && attribute.owner) {\n        const { idColumn, typeColumn } = attribute.morphColumn;\n\n        const idColumnName = identifiers.getName(idColumn.name);\n        const typeColumnName = identifiers.getName(typeColumn.name);\n\n        table.columns.push(\n          createColumn(idColumnName, {\n            type: 'integer',\n            column: {\n              unsigned: true,\n            },\n          })\n        );\n\n        table.columns.push(createColumn(typeColumnName, { type: 'string' }));\n      } else if (\n        'joinColumn' in attribute &&\n        attribute.joinColumn &&\n        attribute.owner &&\n        attribute.joinColumn.referencedTable\n      ) {\n        // NOTE: we could pass uniquness for oneToOne to avoid creating more than one to one\n\n        const {\n          name: columnNameFull,\n          referencedColumn,\n          referencedTable,\n          columnType = 'integer',\n        } = attribute.joinColumn;\n\n        const columnName = identifiers.getName(columnNameFull);\n\n        const column = createColumn(columnName, {\n          // TODO: find the column type automatically, or allow passing all the column params\n          type: columnType,\n          column: {\n            unsigned: true,\n          },\n        });\n\n        table.columns.push(column);\n\n        const fkName = identifiers.getFkIndexName([table.name, columnName]);\n        table.foreignKeys.push({\n          name: fkName,\n          columns: [column.name],\n          referencedTable,\n          referencedColumns: [referencedColumn],\n          // NOTE: could allow configuration\n          onDelete: 'SET NULL',\n        });\n\n        table.indexes.push({\n          name: fkName,\n          columns: [column.name],\n        });\n      }\n    } else if (types.isScalarAttribute(attribute)) {\n      const columnName = identifiers.getName(attribute.columnName || key);\n\n      const column = createColumn(columnName, attribute);\n\n      if (column.unique) {\n        table.indexes.push({\n          type: 'unique',\n          name: identifiers.getUniqueIndexName([table.name, column.name]),\n          columns: [columnName],\n        });\n      }\n\n      if (column.primary) {\n        table.indexes.push({\n          type: 'primary',\n          name: identifiers.getPrimaryIndexName([table.name, column.name]),\n          columns: [columnName],\n        });\n      }\n\n      table.columns.push(column);\n    }\n  }\n\n  return table;\n};\n\nconst getColumnType = (attribute: Attribute) => {\n  if ('columnType' in attribute && attribute.columnType) {\n    return attribute.columnType;\n  }\n\n  switch (attribute.type) {\n    case 'increments': {\n      return {\n        type: 'increments',\n        args: [{ primary: true, primaryKey: true }],\n        notNullable: true,\n      };\n    }\n\n    // We might want to convert email/password to string types before going into the orm with specific validators & transformers\n    case 'password':\n    case 'email':\n    case 'string':\n    case 'enumeration': {\n      return { type: 'string' };\n    }\n    case 'uid': {\n      return {\n        type: 'string',\n      };\n    }\n    case 'richtext':\n    case 'text': {\n      return {\n        type: 'text',\n        args: ['longtext'],\n      };\n    }\n    case 'blocks':\n    case 'json': {\n      return { type: 'jsonb' };\n    }\n    case 'integer': {\n      return { type: 'integer' };\n    }\n    case 'biginteger': {\n      return { type: 'bigInteger' };\n    }\n    case 'float': {\n      return { type: 'double' };\n    }\n    case 'decimal': {\n      return { type: 'decimal', args: [10, 2] };\n    }\n    case 'date': {\n      return { type: 'date' };\n    }\n    case 'time': {\n      return { type: 'time', args: [{ precision: 3 }] };\n    }\n    case 'datetime': {\n      return {\n        type: 'datetime',\n        args: [\n          {\n            useTz: false,\n            precision: 6,\n          },\n        ],\n      };\n    }\n    case 'timestamp': {\n      return {\n        type: 'timestamp',\n        args: [\n          {\n            useTz: false,\n            precision: 6,\n          },\n        ],\n      };\n    }\n    case 'boolean': {\n      return { type: 'boolean' };\n    }\n    default: {\n      throw new Error(`Unknown type ${attribute.type}`);\n    }\n  }\n};\n\nexport const metadataToSchema = (metadata: Metadata): Schema => {\n  const schema: Schema = {\n    tables: [],\n  };\n\n  metadata.forEach((metadata) => {\n    schema.tables.push(createTable(metadata));\n  });\n\n  return schema;\n};\n"],"names":["createColumn","name","attribute","type","args","opts","getColumnType","identifiers","getName","defaultTo","notNullable","unsigned","column","createTable","meta","table","tableName","indexes","foreignKeys","columns","key","Object","keys","attributes","morphColumn","owner","idColumn","typeColumn","idColumnName","typeColumnName","push","joinColumn","referencedTable","columnNameFull","referencedColumn","columnType","columnName","fkName","getFkIndexName","referencedColumns","onDelete","types","unique","getUniqueIndexName","primary","getPrimaryIndexName","primaryKey","precision","useTz","Error","metadataToSchema","metadata","schema","tables","forEach"],"mappings":"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"}

package/dist/schema/storage.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var crypto = require('crypto');
+
+const TABLE_NAME = 'strapi_database_schema';
+var createSchemaStorage = ((db)=>{
+    const hasSchemaTable = ()=>db.getSchemaConnection().hasTable(TABLE_NAME);
+    const createSchemaTable = ()=>{
+        return db.getSchemaConnection().createTable(TABLE_NAME, (t)=>{
+            t.increments('id');
+            t.json('schema');
+            t.datetime('time', {
+                useTz: false
+            });
+            t.string('hash');
+        });
+    };
+    const checkTableExists = async ()=>{
+        if (!await hasSchemaTable()) {
+            await createSchemaTable();
+        }
+    };
+    return {
+        async read () {
+            await checkTableExists();
+            const res = await db.getConnection().select('*').from(TABLE_NAME).orderBy('time', 'DESC').first();
+            if (!res) {
+                return null;
+            }
+            const parsedSchema = typeof res.schema === 'object' ? res.schema : JSON.parse(res.schema);
+            return {
+                ...res,
+                schema: parsedSchema
+            };
+        },
+        hashSchema (schema) {
+            return crypto.createHash('md5').update(JSON.stringify(schema)).digest('hex');
+        },
+        async add (schema) {
+            await checkTableExists();
+            // NOTE: we can remove this to add history
+            await db.getConnection(TABLE_NAME).delete();
+            const time = new Date();
+            await db.getConnection().insert({
+                schema: JSON.stringify(schema),
+                hash: this.hashSchema(schema),
+                time
+            }).into(TABLE_NAME);
+        },
+        async clear () {
+            await checkTableExists();
+            await db.getConnection(TABLE_NAME).truncate();
+        }
+    };
+});
+
+module.exports = createSchemaStorage;
+//# sourceMappingURL=storage.js.map

package/dist/schema/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sources":["../../src/schema/storage.ts"],"sourcesContent":["import crypto from 'crypto';\n\nimport type { Database } from '..';\nimport type { Schema } from './types';\n\nconst TABLE_NAME = 'strapi_database_schema';\n\nexport default (db: Database) => {\n  const hasSchemaTable = () => db.getSchemaConnection().hasTable(TABLE_NAME);\n\n  const createSchemaTable = () => {\n    return db.getSchemaConnection().createTable(TABLE_NAME, (t) => {\n      t.increments('id');\n      t.json('schema');\n      t.datetime('time', { useTz: false });\n      t.string('hash');\n    });\n  };\n\n  const checkTableExists = async () => {\n    if (!(await hasSchemaTable())) {\n      await createSchemaTable();\n    }\n  };\n\n  return {\n    async read(): Promise<{\n      id: number;\n      time: Date;\n      hash: string;\n      schema: Schema;\n    } | null> {\n      await checkTableExists();\n\n      const res = await db\n        .getConnection()\n        .select('*')\n        .from(TABLE_NAME)\n        .orderBy('time', 'DESC')\n        .first();\n\n      if (!res) {\n        return null;\n      }\n\n      const parsedSchema = typeof res.schema === 'object' ? res.schema : JSON.parse(res.schema);\n\n      return {\n        ...res,\n        schema: parsedSchema,\n      };\n    },\n\n    hashSchema(schema: Schema) {\n      return crypto.createHash('md5').update(JSON.stringify(schema)).digest('hex');\n    },\n\n    async add(schema: Schema) {\n      await checkTableExists();\n\n      // NOTE: we can remove this to add history\n      await db.getConnection(TABLE_NAME).delete();\n\n      const time = new Date();\n\n      await db\n        .getConnection()\n        .insert({\n          schema: JSON.stringify(schema),\n          hash: this.hashSchema(schema),\n          time,\n        })\n        .into(TABLE_NAME);\n    },\n\n    async clear() {\n      await checkTableExists();\n\n      await db.getConnection(TABLE_NAME).truncate();\n    },\n  };\n};\n"],"names":["TABLE_NAME","db","hasSchemaTable","getSchemaConnection","hasTable","createSchemaTable","createTable","t","increments","json","datetime","useTz","string","checkTableExists","read","res","getConnection","select","from","orderBy","first","parsedSchema","schema","JSON","parse","hashSchema","crypto","createHash","update","stringify","digest","add","delete","time","Date","insert","hash","into","clear","truncate"],"mappings":";;;;AAKA,MAAMA,UAAa,GAAA,wBAAA;AAEnB,0BAAe,CAAA,CAACC,EAAAA,GAAAA;AACd,IAAA,MAAMC,iBAAiB,IAAMD,EAAAA,CAAGE,mBAAmB,EAAA,CAAGC,QAAQ,CAACJ,UAAAA,CAAAA;AAE/D,IAAA,MAAMK,iBAAoB,GAAA,IAAA;AACxB,QAAA,OAAOJ,GAAGE,mBAAmB,EAAA,CAAGG,WAAW,CAACN,YAAY,CAACO,CAAAA,GAAAA;AACvDA,YAAAA,CAAAA,CAAEC,UAAU,CAAC,IAAA,CAAA;AACbD,YAAAA,CAAAA,CAAEE,IAAI,CAAC,QAAA,CAAA;YACPF,CAAEG,CAAAA,QAAQ,CAAC,MAAQ,EAAA;gBAAEC,KAAO,EAAA;AAAM,aAAA,CAAA;AAClCJ,YAAAA,CAAAA,CAAEK,MAAM,CAAC,MAAA,CAAA;AACX,SAAA,CAAA;AACF,KAAA;AAEA,IAAA,MAAMC,gBAAmB,GAAA,UAAA;QACvB,IAAI,CAAE,MAAMX,cAAmB,EAAA,EAAA;YAC7B,MAAMG,iBAAAA,EAAAA;AACR;AACF,KAAA;IAEA,OAAO;QACL,MAAMS,IAAAA,CAAAA,GAAAA;YAMJ,MAAMD,gBAAAA,EAAAA;AAEN,YAAA,MAAME,GAAM,GAAA,MAAMd,EACfe,CAAAA,aAAa,GACbC,MAAM,CAAC,GACPC,CAAAA,CAAAA,IAAI,CAAClB,UACLmB,CAAAA,CAAAA,OAAO,CAAC,MAAA,EAAQ,QAChBC,KAAK,EAAA;AAER,YAAA,IAAI,CAACL,GAAK,EAAA;gBACR,OAAO,IAAA;AACT;AAEA,YAAA,MAAMM,YAAe,GAAA,OAAON,GAAIO,CAAAA,MAAM,KAAK,QAAA,GAAWP,GAAIO,CAAAA,MAAM,GAAGC,IAAAA,CAAKC,KAAK,CAACT,IAAIO,MAAM,CAAA;YAExF,OAAO;AACL,gBAAA,GAAGP,GAAG;gBACNO,MAAQD,EAAAA;AACV,aAAA;AACF,SAAA;AAEAI,QAAAA,UAAAA,CAAAA,CAAWH,MAAc,EAAA;YACvB,OAAOI,MAAAA,CAAOC,UAAU,CAAC,KAAOC,CAAAA,CAAAA,MAAM,CAACL,IAAAA,CAAKM,SAAS,CAACP,MAASQ,CAAAA,CAAAA,CAAAA,MAAM,CAAC,KAAA,CAAA;AACxE,SAAA;AAEA,QAAA,MAAMC,KAAIT,MAAc,EAAA;YACtB,MAAMT,gBAAAA,EAAAA;;AAGN,YAAA,MAAMZ,EAAGe,CAAAA,aAAa,CAAChB,UAAAA,CAAAA,CAAYgC,MAAM,EAAA;AAEzC,YAAA,MAAMC,OAAO,IAAIC,IAAAA,EAAAA;AAEjB,YAAA,MAAMjC,EACHe,CAAAA,aAAa,EACbmB,CAAAA,MAAM,CAAC;gBACNb,MAAQC,EAAAA,IAAAA,CAAKM,SAAS,CAACP,MAAAA,CAAAA;gBACvBc,IAAM,EAAA,IAAI,CAACX,UAAU,CAACH,MAAAA,CAAAA;AACtBW,gBAAAA;AACF,aAAA,CAAA,CACCI,IAAI,CAACrC,UAAAA,CAAAA;AACV,SAAA;QAEA,MAAMsC,KAAAA,CAAAA,GAAAA;YACJ,MAAMzB,gBAAAA,EAAAA;AAEN,YAAA,MAAMZ,EAAGe,CAAAA,aAAa,CAAChB,UAAAA,CAAAA,CAAYuC,QAAQ,EAAA;AAC7C;AACF,KAAA;AACF,CAAA;;;;"}