node_modules ignore

server/node_modules/@strapi/database/dist/dialects/mysql/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MYSQL = "MYSQL";
+export declare const MARIADB = "MARIADB";
+//# sourceMappingURL=constants.d.ts.map

server/node_modules/@strapi/database/dist/dialects/mysql/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/dialects/mysql/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,UAAU,CAAC;AAC7B,eAAO,MAAM,OAAO,YAAY,CAAC"}

server/node_modules/@strapi/database/dist/dialects/mysql/constants.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const MYSQL = 'MYSQL';
+const MARIADB = 'MARIADB';
+
+exports.MARIADB = MARIADB;
+exports.MYSQL = MYSQL;
+//# sourceMappingURL=constants.js.map

server/node_modules/@strapi/database/dist/dialects/mysql/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../src/dialects/mysql/constants.ts"],"sourcesContent":["export const MYSQL = 'MYSQL';\nexport const MARIADB = 'MARIADB';\n"],"names":["MYSQL","MARIADB"],"mappings":";;AAAO,MAAMA,QAAQ;AACd,MAAMC,UAAU;;;;;"}

server/node_modules/@strapi/database/dist/dialects/mysql/constants.mjs

@@ -0,0 +1,5 @@
+const MYSQL = 'MYSQL';
+const MARIADB = 'MARIADB';
+
+export { MARIADB, MYSQL };
+//# sourceMappingURL=constants.mjs.map

server/node_modules/@strapi/database/dist/dialects/mysql/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","sources":["../../../src/dialects/mysql/constants.ts"],"sourcesContent":["export const MYSQL = 'MYSQL';\nexport const MARIADB = 'MARIADB';\n"],"names":["MYSQL","MARIADB"],"mappings":"AAAO,MAAMA,QAAQ;AACd,MAAMC,UAAU;;;;"}

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.d.ts

@@ -0,0 +1,12 @@
+import { MARIADB, MYSQL } from './constants';
+import type { Database } from '../..';
+export interface Information {
+    database: typeof MARIADB | typeof MYSQL | null;
+    version: string | null;
+}
+export default class MysqlDatabaseInspector {
+    db: Database;
+    constructor(db: Database);
+    getInformation(nativeConnection?: unknown): Promise<Information>;
+}
+//# sourceMappingURL=database-inspector.d.ts.map

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-inspector.d.ts","sourceRoot":"","sources":["../../../src/dialects/mysql/database-inspector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,OAAO,GAAG,OAAO,KAAK,GAAG,IAAI,CAAC;IAC/C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAMD,MAAM,CAAC,OAAO,OAAO,sBAAsB;IACzC,EAAE,EAAE,QAAQ,CAAC;gBAED,EAAE,EAAE,QAAQ;IAIlB,cAAc,CAAC,gBAAgB,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC;CAuBvE"}

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var constants = require('./constants.js');
+
+const SQL_QUERIES = {
+    VERSION: `SELECT version() as version`
+};
+class MysqlDatabaseInspector {
+    async getInformation(nativeConnection) {
+        let database;
+        let versionNumber;
+        try {
+            const [results] = await this.db.connection.raw(SQL_QUERIES.VERSION).connection(nativeConnection);
+            const versionSplit = results[0].version.split('-');
+            const databaseName = versionSplit[1];
+            versionNumber = versionSplit[0];
+            database = databaseName && databaseName.toLowerCase() === 'mariadb' ? constants.MARIADB : constants.MYSQL;
+        } catch (e) {
+            return {
+                database: null,
+                version: null
+            };
+        }
+        return {
+            database,
+            version: versionNumber
+        };
+    }
+    constructor(db){
+        this.db = db;
+    }
+}
+
+module.exports = MysqlDatabaseInspector;
+//# sourceMappingURL=database-inspector.js.map

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-inspector.js","sources":["../../../src/dialects/mysql/database-inspector.ts"],"sourcesContent":["import { MARIADB, MYSQL } from './constants';\nimport type { Database } from '../..';\n\nexport interface Information {\n  database: typeof MARIADB | typeof MYSQL | null;\n  version: string | null;\n}\n\nconst SQL_QUERIES = {\n  VERSION: `SELECT version() as version`,\n};\n\nexport default class MysqlDatabaseInspector {\n  db: Database;\n\n  constructor(db: Database) {\n    this.db = db;\n  }\n\n  async getInformation(nativeConnection?: unknown): Promise<Information> {\n    let database: Information['database'];\n    let versionNumber: Information['version'];\n    try {\n      const [results] = await this.db.connection\n        .raw(SQL_QUERIES.VERSION)\n        .connection(nativeConnection);\n      const versionSplit = results[0].version.split('-');\n      const databaseName = versionSplit[1];\n      versionNumber = versionSplit[0];\n      database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;\n    } catch (e) {\n      return {\n        database: null,\n        version: null,\n      };\n    }\n\n    return {\n      database,\n      version: versionNumber,\n    };\n  }\n}\n"],"names":["SQL_QUERIES","VERSION","MysqlDatabaseInspector","getInformation","nativeConnection","database","versionNumber","results","db","connection","raw","versionSplit","version","split","databaseName","toLowerCase","MARIADB","MYSQL","e","constructor"],"mappings":";;;;AAQA,MAAMA,WAAc,GAAA;IAClBC,OAAS,EAAA,CAAC,2BAA2B;AACvC,CAAA;AAEe,MAAMC,sBAAAA,CAAAA;IAOnB,MAAMC,cAAAA,CAAeC,gBAA0B,EAAwB;QACrE,IAAIC,QAAAA;QACJ,IAAIC,aAAAA;QACJ,IAAI;AACF,YAAA,MAAM,CAACC,OAAQ,CAAA,GAAG,MAAM,IAAI,CAACC,EAAE,CAACC,UAAU,CACvCC,GAAG,CAACV,WAAAA,CAAYC,OAAO,CAAA,CACvBQ,UAAU,CAACL,gBAAAA,CAAAA;YACd,MAAMO,YAAAA,GAAeJ,OAAO,CAAC,CAAA,CAAE,CAACK,OAAO,CAACC,KAAK,CAAC,GAAA,CAAA;YAC9C,MAAMC,YAAAA,GAAeH,YAAY,CAAC,CAAE,CAAA;YACpCL,aAAgBK,GAAAA,YAAY,CAAC,CAAE,CAAA;AAC/BN,YAAAA,QAAAA,GAAWS,YAAgBA,IAAAA,YAAAA,CAAaC,WAAW,EAAA,KAAO,YAAYC,iBAAUC,GAAAA,eAAAA;AAClF,SAAA,CAAE,OAAOC,CAAG,EAAA;YACV,OAAO;gBACLb,QAAU,EAAA,IAAA;gBACVO,OAAS,EAAA;AACX,aAAA;AACF;QAEA,OAAO;AACLP,YAAAA,QAAAA;YACAO,OAASN,EAAAA;AACX,SAAA;AACF;AA1BAa,IAAAA,WAAAA,CAAYX,EAAY,CAAE;QACxB,IAAI,CAACA,EAAE,GAAGA,EAAAA;AACZ;AAyBF;;;;"}

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.mjs

@@ -0,0 +1,33 @@
+import { MARIADB, MYSQL } from './constants.mjs';
+
+const SQL_QUERIES = {
+    VERSION: `SELECT version() as version`
+};
+class MysqlDatabaseInspector {
+    async getInformation(nativeConnection) {
+        let database;
+        let versionNumber;
+        try {
+            const [results] = await this.db.connection.raw(SQL_QUERIES.VERSION).connection(nativeConnection);
+            const versionSplit = results[0].version.split('-');
+            const databaseName = versionSplit[1];
+            versionNumber = versionSplit[0];
+            database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;
+        } catch (e) {
+            return {
+                database: null,
+                version: null
+            };
+        }
+        return {
+            database,
+            version: versionNumber
+        };
+    }
+    constructor(db){
+        this.db = db;
+    }
+}
+
+export { MysqlDatabaseInspector as default };
+//# sourceMappingURL=database-inspector.mjs.map

server/node_modules/@strapi/database/dist/dialects/mysql/database-inspector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-inspector.mjs","sources":["../../../src/dialects/mysql/database-inspector.ts"],"sourcesContent":["import { MARIADB, MYSQL } from './constants';\nimport type { Database } from '../..';\n\nexport interface Information {\n  database: typeof MARIADB | typeof MYSQL | null;\n  version: string | null;\n}\n\nconst SQL_QUERIES = {\n  VERSION: `SELECT version() as version`,\n};\n\nexport default class MysqlDatabaseInspector {\n  db: Database;\n\n  constructor(db: Database) {\n    this.db = db;\n  }\n\n  async getInformation(nativeConnection?: unknown): Promise<Information> {\n    let database: Information['database'];\n    let versionNumber: Information['version'];\n    try {\n      const [results] = await this.db.connection\n        .raw(SQL_QUERIES.VERSION)\n        .connection(nativeConnection);\n      const versionSplit = results[0].version.split('-');\n      const databaseName = versionSplit[1];\n      versionNumber = versionSplit[0];\n      database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;\n    } catch (e) {\n      return {\n        database: null,\n        version: null,\n      };\n    }\n\n    return {\n      database,\n      version: versionNumber,\n    };\n  }\n}\n"],"names":["SQL_QUERIES","VERSION","MysqlDatabaseInspector","getInformation","nativeConnection","database","versionNumber","results","db","connection","raw","versionSplit","version","split","databaseName","toLowerCase","MARIADB","MYSQL","e","constructor"],"mappings":";;AAQA,MAAMA,WAAc,GAAA;IAClBC,OAAS,EAAA,CAAC,2BAA2B;AACvC,CAAA;AAEe,MAAMC,sBAAAA,CAAAA;IAOnB,MAAMC,cAAAA,CAAeC,gBAA0B,EAAwB;QACrE,IAAIC,QAAAA;QACJ,IAAIC,aAAAA;QACJ,IAAI;AACF,YAAA,MAAM,CAACC,OAAQ,CAAA,GAAG,MAAM,IAAI,CAACC,EAAE,CAACC,UAAU,CACvCC,GAAG,CAACV,WAAAA,CAAYC,OAAO,CAAA,CACvBQ,UAAU,CAACL,gBAAAA,CAAAA;YACd,MAAMO,YAAAA,GAAeJ,OAAO,CAAC,CAAA,CAAE,CAACK,OAAO,CAACC,KAAK,CAAC,GAAA,CAAA;YAC9C,MAAMC,YAAAA,GAAeH,YAAY,CAAC,CAAE,CAAA;YACpCL,aAAgBK,GAAAA,YAAY,CAAC,CAAE,CAAA;AAC/BN,YAAAA,QAAAA,GAAWS,YAAgBA,IAAAA,YAAAA,CAAaC,WAAW,EAAA,KAAO,YAAYC,OAAUC,GAAAA,KAAAA;AAClF,SAAA,CAAE,OAAOC,CAAG,EAAA;YACV,OAAO;gBACLb,QAAU,EAAA,IAAA;gBACVO,OAAS,EAAA;AACX,aAAA;AACF;QAEA,OAAO;AACLP,YAAAA,QAAAA;YACAO,OAASN,EAAAA;AACX,SAAA;AACF;AA1BAa,IAAAA,WAAAA,CAAYX,EAAY,CAAE;QACxB,IAAI,CAACA,EAAE,GAAGA,EAAAA;AACZ;AAyBF;;;;"}

server/node_modules/@strapi/database/dist/dialects/mysql/index.d.ts

@@ -0,0 +1,19 @@
+import Dialect from '../dialect';
+import MysqlSchemaInspector from './schema-inspector';
+import MysqlDatabaseInspector from './database-inspector';
+import type { Database } from '../..';
+import type { Information } from './database-inspector';
+export default class MysqlDialect extends Dialect {
+    schemaInspector: MysqlSchemaInspector;
+    databaseInspector: MysqlDatabaseInspector;
+    info: Information | null;
+    constructor(db: Database);
+    configure(): void;
+    initialize(nativeConnection: unknown): Promise<void>;
+    startSchemaUpdate(): Promise<void>;
+    endSchemaUpdate(): Promise<void>;
+    supportsUnsigned(): boolean;
+    usesForeignKeys(): boolean;
+    transformErrors(error: Error): void;
+}
+//# sourceMappingURL=index.d.ts.map

server/node_modules/@strapi/database/dist/dialects/mysql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialects/mysql/index.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,MAAM,YAAY,CAAC;AACjC,OAAO,oBAAoB,MAAM,oBAAoB,CAAC;AACtD,OAAO,sBAAsB,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,OAAO;IAC/C,eAAe,EAAE,oBAAoB,CAAC;IAEtC,iBAAiB,EAAE,sBAAsB,CAAC;IAE1C,IAAI,EAAE,WAAW,GAAG,IAAI,CAAQ;gBAEpB,EAAE,EAAE,QAAQ;IAOxB,SAAS;IA+BH,UAAU,CAAC,gBAAgB,EAAE,OAAO;IAoBpC,iBAAiB;IASjB,eAAe;IAIrB,gBAAgB;IAIhB,eAAe;IAIf,eAAe,CAAC,KAAK,EAAE,KAAK;CAG7B"}

server/node_modules/@strapi/database/dist/dialects/mysql/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var dialect = require('../dialect.js');
+var schemaInspector = require('./schema-inspector.js');
+var databaseInspector = require('./database-inspector.js');
+
+class MysqlDialect extends dialect {
+    configure() {
+        const connection = this.db.config.connection.connection;
+        connection.supportBigNumbers = true;
+        // Only allow bigNumberStrings option set to be true if no connection option passed
+        // Otherwise bigNumberStrings option should be allowed to used from DB config
+        if (connection.bigNumberStrings === undefined) {
+            connection.bigNumberStrings = true;
+        }
+        connection.typeCast = (field, next)=>{
+            if (field.type === 'DECIMAL' || field.type === 'NEWDECIMAL') {
+                const value = field.string();
+                return value === null ? null : Number(value);
+            }
+            if (field.type === 'TINY' && field.length === 1) {
+                const value = field.string();
+                return value ? value === '1' : null;
+            }
+            if (field.type === 'DATE') {
+                return field.string();
+            }
+            return next();
+        };
+    }
+    async initialize(nativeConnection) {
+        try {
+            await this.db.connection.raw(`set session sql_require_primary_key = 0;`).connection(nativeConnection);
+        } catch (err) {
+        // Ignore error due to lack of session permissions
+        }
+        // We only need to get info on the first connection in the pool
+        /**
+     * Note: There is a race condition here where if two connections are opened at the same time, both will retrieve
+     * db info, but it doesn't cause issues, it's just one wasted query one time, so we can safely leave it to avoid
+     * adding extra complexity
+     * */ if (!this.info) {
+            this.info = await this.databaseInspector.getInformation(nativeConnection);
+        }
+    }
+    async startSchemaUpdate() {
+        try {
+            await this.db.connection.raw(`set foreign_key_checks = 0;`);
+            await this.db.connection.raw(`set session sql_require_primary_key = 0;`);
+        } catch (err) {
+        // Ignore error due to lack of session permissions
+        }
+    }
+    async endSchemaUpdate() {
+        await this.db.connection.raw(`set foreign_key_checks = 1;`);
+    }
+    supportsUnsigned() {
+        return true;
+    }
+    usesForeignKeys() {
+        return true;
+    }
+    transformErrors(error) {
+        super.transformErrors(error);
+    }
+    constructor(db){
+        super(db, 'mysql');
+        this.info = null;
+        this.schemaInspector = new schemaInspector(db);
+        this.databaseInspector = new databaseInspector(db);
+    }
+}
+
+module.exports = MysqlDialect;
+//# sourceMappingURL=index.js.map

server/node_modules/@strapi/database/dist/dialects/mysql/index.mjs

@@ -0,0 +1,73 @@
+import Dialect from '../dialect.mjs';
+import MysqlSchemaInspector from './schema-inspector.mjs';
+import MysqlDatabaseInspector from './database-inspector.mjs';
+
+class MysqlDialect extends Dialect {
+    configure() {
+        const connection = this.db.config.connection.connection;
+        connection.supportBigNumbers = true;
+        // Only allow bigNumberStrings option set to be true if no connection option passed
+        // Otherwise bigNumberStrings option should be allowed to used from DB config
+        if (connection.bigNumberStrings === undefined) {
+            connection.bigNumberStrings = true;
+        }
+        connection.typeCast = (field, next)=>{
+            if (field.type === 'DECIMAL' || field.type === 'NEWDECIMAL') {
+                const value = field.string();
+                return value === null ? null : Number(value);
+            }
+            if (field.type === 'TINY' && field.length === 1) {
+                const value = field.string();
+                return value ? value === '1' : null;
+            }
+            if (field.type === 'DATE') {
+                return field.string();
+            }
+            return next();
+        };
+    }
+    async initialize(nativeConnection) {
+        try {
+            await this.db.connection.raw(`set session sql_require_primary_key = 0;`).connection(nativeConnection);
+        } catch (err) {
+        // Ignore error due to lack of session permissions
+        }
+        // We only need to get info on the first connection in the pool
+        /**
+     * Note: There is a race condition here where if two connections are opened at the same time, both will retrieve
+     * db info, but it doesn't cause issues, it's just one wasted query one time, so we can safely leave it to avoid
+     * adding extra complexity
+     * */ if (!this.info) {
+            this.info = await this.databaseInspector.getInformation(nativeConnection);
+        }
+    }
+    async startSchemaUpdate() {
+        try {
+            await this.db.connection.raw(`set foreign_key_checks = 0;`);
+            await this.db.connection.raw(`set session sql_require_primary_key = 0;`);
+        } catch (err) {
+        // Ignore error due to lack of session permissions
+        }
+    }
+    async endSchemaUpdate() {
+        await this.db.connection.raw(`set foreign_key_checks = 1;`);
+    }
+    supportsUnsigned() {
+        return true;
+    }
+    usesForeignKeys() {
+        return true;
+    }
+    transformErrors(error) {
+        super.transformErrors(error);
+    }
+    constructor(db){
+        super(db, 'mysql');
+        this.info = null;
+        this.schemaInspector = new MysqlSchemaInspector(db);
+        this.databaseInspector = new MysqlDatabaseInspector(db);
+    }
+}
+
+export { MysqlDialect as default };
+//# sourceMappingURL=index.mjs.map

server/node_modules/@strapi/database/dist/dialects/mysql/schema-inspector.d.ts

@@ -0,0 +1,13 @@
+import type { Column, ForeignKey, Index, Schema } from '../../schema/types';
+import type { SchemaInspector } from '../dialect';
+import type { Database } from '../..';
+export default class MysqlSchemaInspector implements SchemaInspector {
+    db: Database;
+    constructor(db: Database);
+    getSchema(): Promise<Schema>;
+    getTables(): Promise<string[]>;
+    getColumns(tableName: string): Promise<Column[]>;
+    getIndexes(tableName: string): Promise<Index[]>;
+    getForeignKeys(tableName: string): Promise<ForeignKey[]>;
+}
+//# sourceMappingURL=schema-inspector.d.ts.map

server/node_modules/@strapi/database/dist/dialects/mysql/schema-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-inspector.d.ts","sourceRoot":"","sources":["../../../src/dialects/mysql/schema-inspector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAsItC,MAAM,CAAC,OAAO,OAAO,oBAAqB,YAAW,eAAe;IAClE,EAAE,EAAE,QAAQ,CAAC;gBAED,EAAE,EAAE,QAAQ;IAIlB,SAAS;IAuBT,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAM9B,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAoBhD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IA4B/C,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;CA+C/D"}

server/node_modules/@strapi/database/dist/dialects/mysql/schema-inspector.js

@@ -0,0 +1,297 @@
+'use strict';
+
+const SQL_QUERIES = {
+    TABLE_LIST: /* sql */ `
+    SELECT
+      t.table_name as table_name
+    FROM information_schema.tables t
+    WHERE table_type = 'BASE TABLE'
+    AND table_schema = schema();
+  `,
+    LIST_COLUMNS: /* sql */ `
+    SELECT
+      c.data_type as data_type,
+      c.column_name as column_name,
+      c.character_maximum_length as character_maximum_length,
+      c.column_default as column_default,
+      c.is_nullable as is_nullable,
+      c.column_type as column_type,
+      c.column_key as column_key
+    FROM information_schema.columns c
+    WHERE table_schema = database()
+    AND table_name = ?;
+  `,
+    INDEX_LIST: /* sql */ `
+    show index from ??;
+  `,
+    FOREIGN_KEY_LIST: /* sql */ `
+    SELECT
+      tc.constraint_name as constraint_name
+    FROM information_schema.table_constraints tc
+    WHERE tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = database()
+    AND tc.table_name = ?;
+  `,
+    FOREIGN_KEY_REFERENCES: /* sql */ `
+    SELECT
+      kcu.constraint_name as constraint_name,
+      kcu.column_name as column_name,
+      kcu.referenced_table_name as referenced_table_name,
+      kcu.referenced_column_name as referenced_column_name
+    FROM information_schema.key_column_usage kcu
+    WHERE kcu.constraint_name in (?)
+    AND kcu.table_schema = database()
+    AND kcu.table_name = ?;
+  `,
+    FOREIGN_KEY_REFERENTIALS_CONSTRAINTS: /* sql */ `
+    SELECT
+      rc.constraint_name as constraint_name,
+      rc.update_rule as on_update,
+      rc.delete_rule as on_delete
+    FROM information_schema.referential_constraints AS rc
+    WHERE rc.constraint_name in (?)
+    AND rc.constraint_schema = database()
+    AND rc.table_name = ?;
+  `
+};
+const toStrapiType = (column)=>{
+    const rootType = column.data_type.toLowerCase().match(/[^(), ]+/)?.[0];
+    switch(rootType){
+        case 'int':
+            {
+                if (column.column_key === 'PRI') {
+                    return {
+                        type: 'increments',
+                        args: [
+                            {
+                                primary: true,
+                                primaryKey: true
+                            }
+                        ],
+                        unsigned: false
+                    };
+                }
+                return {
+                    type: 'integer'
+                };
+            }
+        case 'decimal':
+            {
+                return {
+                    type: 'decimal',
+                    args: [
+                        10,
+                        2
+                    ]
+                };
+            }
+        case 'double':
+            {
+                return {
+                    type: 'double'
+                };
+            }
+        case 'bigint':
+            {
+                return {
+                    type: 'bigInteger'
+                };
+            }
+        case 'enum':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'tinyint':
+            {
+                return {
+                    type: 'boolean'
+                };
+            }
+        case 'longtext':
+            {
+                return {
+                    type: 'text',
+                    args: [
+                        'longtext'
+                    ]
+                };
+            }
+        case 'varchar':
+            {
+                return {
+                    type: 'string',
+                    args: [
+                        column.character_maximum_length
+                    ]
+                };
+            }
+        case 'datetime':
+            {
+                return {
+                    type: 'datetime',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'date':
+            {
+                return {
+                    type: 'date'
+                };
+            }
+        case 'time':
+            {
+                return {
+                    type: 'time',
+                    args: [
+                        {
+                            precision: 3
+                        }
+                    ]
+                };
+            }
+        case 'timestamp':
+            {
+                return {
+                    type: 'timestamp',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'json':
+            {
+                return {
+                    type: 'jsonb'
+                };
+            }
+        default:
+            {
+                return {
+                    type: 'specificType',
+                    args: [
+                        column.data_type
+                    ]
+                };
+            }
+    }
+};
+class MysqlSchemaInspector {
+    async getSchema() {
+        const schema = {
+            tables: []
+        };
+        const tables = await this.getTables();
+        schema.tables = await Promise.all(tables.map(async (tableName)=>{
+            const columns = await this.getColumns(tableName);
+            const indexes = await this.getIndexes(tableName);
+            const foreignKeys = await this.getForeignKeys(tableName);
+            return {
+                name: tableName,
+                columns,
+                indexes,
+                foreignKeys
+            };
+        }));
+        return schema;
+    }
+    async getTables() {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST);
+        return rows.map((row)=>row.table_name);
+    }
+    async getColumns(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.LIST_COLUMNS, [
+            tableName
+        ]);
+        return rows.map((row)=>{
+            const { type, args = [], ...rest } = toStrapiType(row);
+            return {
+                type,
+                args,
+                defaultTo: row.column_default,
+                name: row.column_name,
+                notNullable: row.is_nullable === 'NO',
+                unsigned: row.column_type.endsWith(' unsigned'),
+                ...rest
+            };
+        });
+    }
+    async getIndexes(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [
+            tableName
+        ]);
+        const ret = {};
+        for (const index of rows){
+            if (index.Column_name === 'id') {
+                continue;
+            }
+            if (!ret[index.Key_name]) {
+                const indexInfo = {
+                    columns: [
+                        index.Column_name
+                    ],
+                    name: index.Key_name
+                };
+                if (!index.Non_unique || index.Non_unique === '0') {
+                    indexInfo.type = 'unique';
+                }
+                ret[index.Key_name] = indexInfo;
+            } else {
+                ret[index.Key_name].columns.push(index.Column_name);
+            }
+        }
+        return Object.values(ret);
+    }
+    async getForeignKeys(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [
+            tableName
+        ]);
+        const ret = {};
+        for (const fk of rows){
+            ret[fk.constraint_name] = {
+                name: fk.constraint_name,
+                columns: [],
+                referencedColumns: [],
+                referencedTable: null,
+                onUpdate: null,
+                onDelete: null
+            };
+        }
+        const contraintNames = Object.keys(ret);
+        if (contraintNames.length > 0) {
+            const [fkReferences] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES, [
+                contraintNames,
+                tableName
+            ]);
+            for (const fkReference of fkReferences){
+                ret[fkReference.constraint_name].referencedTable = fkReference.referenced_table_name;
+                ret[fkReference.constraint_name].columns.push(fkReference.column_name);
+                ret[fkReference.constraint_name].referencedColumns.push(fkReference.referenced_column_name);
+            }
+            const [fkReferentialConstraints] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENTIALS_CONSTRAINTS, [
+                contraintNames,
+                tableName
+            ]);
+            for (const fkReferentialConstraint of fkReferentialConstraints){
+                ret[fkReferentialConstraint.constraint_name].onUpdate = fkReferentialConstraint.on_update.toUpperCase();
+                ret[fkReferentialConstraint.constraint_name].onDelete = fkReferentialConstraint.on_delete.toUpperCase();
+            }
+        }
+        return Object.values(ret);
+    }
+    constructor(db){
+        this.db = db;
+    }
+}
+
+module.exports = MysqlSchemaInspector;
+//# sourceMappingURL=schema-inspector.js.map

server/node_modules/@strapi/database/dist/dialects/mysql/schema-inspector.mjs

@@ -0,0 +1,295 @@
+const SQL_QUERIES = {
+    TABLE_LIST: /* sql */ `
+    SELECT
+      t.table_name as table_name
+    FROM information_schema.tables t
+    WHERE table_type = 'BASE TABLE'
+    AND table_schema = schema();
+  `,
+    LIST_COLUMNS: /* sql */ `
+    SELECT
+      c.data_type as data_type,
+      c.column_name as column_name,
+      c.character_maximum_length as character_maximum_length,
+      c.column_default as column_default,
+      c.is_nullable as is_nullable,
+      c.column_type as column_type,
+      c.column_key as column_key
+    FROM information_schema.columns c
+    WHERE table_schema = database()
+    AND table_name = ?;
+  `,
+    INDEX_LIST: /* sql */ `
+    show index from ??;
+  `,
+    FOREIGN_KEY_LIST: /* sql */ `
+    SELECT
+      tc.constraint_name as constraint_name
+    FROM information_schema.table_constraints tc
+    WHERE tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = database()
+    AND tc.table_name = ?;
+  `,
+    FOREIGN_KEY_REFERENCES: /* sql */ `
+    SELECT
+      kcu.constraint_name as constraint_name,
+      kcu.column_name as column_name,
+      kcu.referenced_table_name as referenced_table_name,
+      kcu.referenced_column_name as referenced_column_name
+    FROM information_schema.key_column_usage kcu
+    WHERE kcu.constraint_name in (?)
+    AND kcu.table_schema = database()
+    AND kcu.table_name = ?;
+  `,
+    FOREIGN_KEY_REFERENTIALS_CONSTRAINTS: /* sql */ `
+    SELECT
+      rc.constraint_name as constraint_name,
+      rc.update_rule as on_update,
+      rc.delete_rule as on_delete
+    FROM information_schema.referential_constraints AS rc
+    WHERE rc.constraint_name in (?)
+    AND rc.constraint_schema = database()
+    AND rc.table_name = ?;
+  `
+};
+const toStrapiType = (column)=>{
+    const rootType = column.data_type.toLowerCase().match(/[^(), ]+/)?.[0];
+    switch(rootType){
+        case 'int':
+            {
+                if (column.column_key === 'PRI') {
+                    return {
+                        type: 'increments',
+                        args: [
+                            {
+                                primary: true,
+                                primaryKey: true
+                            }
+                        ],
+                        unsigned: false
+                    };
+                }
+                return {
+                    type: 'integer'
+                };
+            }
+        case 'decimal':
+            {
+                return {
+                    type: 'decimal',
+                    args: [
+                        10,
+                        2
+                    ]
+                };
+            }
+        case 'double':
+            {
+                return {
+                    type: 'double'
+                };
+            }
+        case 'bigint':
+            {
+                return {
+                    type: 'bigInteger'
+                };
+            }
+        case 'enum':
+            {
+                return {
+                    type: 'string'
+                };
+            }
+        case 'tinyint':
+            {
+                return {
+                    type: 'boolean'
+                };
+            }
+        case 'longtext':
+            {
+                return {
+                    type: 'text',
+                    args: [
+                        'longtext'
+                    ]
+                };
+            }
+        case 'varchar':
+            {
+                return {
+                    type: 'string',
+                    args: [
+                        column.character_maximum_length
+                    ]
+                };
+            }
+        case 'datetime':
+            {
+                return {
+                    type: 'datetime',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'date':
+            {
+                return {
+                    type: 'date'
+                };
+            }
+        case 'time':
+            {
+                return {
+                    type: 'time',
+                    args: [
+                        {
+                            precision: 3
+                        }
+                    ]
+                };
+            }
+        case 'timestamp':
+            {
+                return {
+                    type: 'timestamp',
+                    args: [
+                        {
+                            useTz: false,
+                            precision: 6
+                        }
+                    ]
+                };
+            }
+        case 'json':
+            {
+                return {
+                    type: 'jsonb'
+                };
+            }
+        default:
+            {
+                return {
+                    type: 'specificType',
+                    args: [
+                        column.data_type
+                    ]
+                };
+            }
+    }
+};
+class MysqlSchemaInspector {
+    async getSchema() {
+        const schema = {
+            tables: []
+        };
+        const tables = await this.getTables();
+        schema.tables = await Promise.all(tables.map(async (tableName)=>{
+            const columns = await this.getColumns(tableName);
+            const indexes = await this.getIndexes(tableName);
+            const foreignKeys = await this.getForeignKeys(tableName);
+            return {
+                name: tableName,
+                columns,
+                indexes,
+                foreignKeys
+            };
+        }));
+        return schema;
+    }
+    async getTables() {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.TABLE_LIST);
+        return rows.map((row)=>row.table_name);
+    }
+    async getColumns(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.LIST_COLUMNS, [
+            tableName
+        ]);
+        return rows.map((row)=>{
+            const { type, args = [], ...rest } = toStrapiType(row);
+            return {
+                type,
+                args,
+                defaultTo: row.column_default,
+                name: row.column_name,
+                notNullable: row.is_nullable === 'NO',
+                unsigned: row.column_type.endsWith(' unsigned'),
+                ...rest
+            };
+        });
+    }
+    async getIndexes(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.INDEX_LIST, [
+            tableName
+        ]);
+        const ret = {};
+        for (const index of rows){
+            if (index.Column_name === 'id') {
+                continue;
+            }
+            if (!ret[index.Key_name]) {
+                const indexInfo = {
+                    columns: [
+                        index.Column_name
+                    ],
+                    name: index.Key_name
+                };
+                if (!index.Non_unique || index.Non_unique === '0') {
+                    indexInfo.type = 'unique';
+                }
+                ret[index.Key_name] = indexInfo;
+            } else {
+                ret[index.Key_name].columns.push(index.Column_name);
+            }
+        }
+        return Object.values(ret);
+    }
+    async getForeignKeys(tableName) {
+        const [rows] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_LIST, [
+            tableName
+        ]);
+        const ret = {};
+        for (const fk of rows){
+            ret[fk.constraint_name] = {
+                name: fk.constraint_name,
+                columns: [],
+                referencedColumns: [],
+                referencedTable: null,
+                onUpdate: null,
+                onDelete: null
+            };
+        }
+        const contraintNames = Object.keys(ret);
+        if (contraintNames.length > 0) {
+            const [fkReferences] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENCES, [
+                contraintNames,
+                tableName
+            ]);
+            for (const fkReference of fkReferences){
+                ret[fkReference.constraint_name].referencedTable = fkReference.referenced_table_name;
+                ret[fkReference.constraint_name].columns.push(fkReference.column_name);
+                ret[fkReference.constraint_name].referencedColumns.push(fkReference.referenced_column_name);
+            }
+            const [fkReferentialConstraints] = await this.db.connection.raw(SQL_QUERIES.FOREIGN_KEY_REFERENTIALS_CONSTRAINTS, [
+                contraintNames,
+                tableName
+            ]);
+            for (const fkReferentialConstraint of fkReferentialConstraints){
+                ret[fkReferentialConstraint.constraint_name].onUpdate = fkReferentialConstraint.on_update.toUpperCase();
+                ret[fkReferentialConstraint.constraint_name].onDelete = fkReferentialConstraint.on_delete.toUpperCase();
+            }
+        }
+        return Object.values(ret);
+    }
+    constructor(db){
+        this.db = db;
+    }
+}
+
+export { MysqlSchemaInspector as default };
+//# sourceMappingURL=schema-inspector.mjs.map