strapi/packages/strapi-hook-bookshelf/lib/buildDatabaseSchema.js

486 lines
14 KiB
JavaScript

const _ = require('lodash');
const { singular } = require('pluralize');
/* global StrapiConfigs */
module.exports = async ({
ORM,
loadedModel,
definition,
connection,
model,
}) => {
const { hasTimestamps } = loadedModel;
let [createAtCol, updatedAtCol] = ['created_at', 'updated_at'];
if (Array.isArray(hasTimestamps)) {
[createAtCol, updatedAtCol] = hasTimestamps;
}
// Equilize database tables
const createOrUpdateTable = async (table, attributes) => {
const tableExists = await ORM.knex.schema.hasTable(table);
const generateIndexes = async table => {
try {
const connection = strapi.config.connections[definition.connection];
let columns = Object.keys(attributes).filter(attribute =>
['string', 'text'].includes(attributes[attribute].type)
);
if (!columns.length) {
// No text columns founds, exit from creating Fulltext Index
return;
}
switch (connection.settings.client) {
case 'mysql':
columns = columns.map(attribute => `\`${attribute}\``).join(',');
// Create fulltext indexes for every column.
await ORM.knex.raw(
`CREATE FULLTEXT INDEX SEARCH_${_.toUpper(
_.snakeCase(table)
)} ON \`${table}\` (${columns})`
);
break;
case 'pg': {
// Enable extension to allow GIN indexes.
await ORM.knex.raw('CREATE EXTENSION IF NOT EXISTS pg_trgm');
// Create GIN indexes for every column.
const indexes = columns.map(column => {
const indexName = `${_.snakeCase(table)}_${column}`;
const attribute =
_.toLower(column) === column ? column : `"${column}"`;
return ORM.knex.raw(
`CREATE INDEX IF NOT EXISTS search_${_.toLower(
indexName
)} ON "${table}" USING gin(${attribute} gin_trgm_ops)`
);
});
await Promise.all(indexes);
break;
}
}
} catch (e) {
// Handle duplicate errors.
if (e.errno !== 1061 && e.code !== '42P07') {
if (_.get(connection, 'options.debug') === true) {
console.log(e);
}
strapi.log.warn(
`The SQL database indexes haven't been generated successfully. Please enable the debug mode for more details.`
);
}
}
};
const buildColumns = (tbl, columns, opts = {}) => {
const { tableExists, alter = false } = opts;
Object.keys(columns).forEach(key => {
const attribute = columns[key];
const type = getType({
definition,
attribute,
name: key,
tableExists,
});
if (type) {
const col = tbl.specificType(key, type);
if (attribute.required === true) {
if (definition.client !== 'sqlite3' || !tableExists) {
col.notNullable();
}
} else {
col.nullable();
}
if (attribute.unique === true) {
if (definition.client !== 'sqlite3' || !tableExists) {
tbl.unique(key, uniqueColName(table, key));
}
}
if (alter) {
col.alter();
}
}
});
};
const createColumns = (tbl, columns, opts = {}) => {
return buildColumns(tbl, columns, opts);
};
const alterColumns = (tbl, columns, opts = {}) => {
return createColumns(tbl, columns, { ...opts, alter: true });
};
const createTable = (table, { trx = ORM.knex, ...opts } = {}) => {
return trx.schema.createTable(table, tbl => {
tbl.specificType('id', getIdType(definition));
createColumns(tbl, attributes, { ...opts, tableExists: false });
});
};
if (!tableExists) {
await createTable(table);
await generateIndexes(table);
await storeTable(table, attributes);
return;
}
const columns = Object.keys(attributes);
// Fetch existing column
const columnsExist = await Promise.all(
columns.map(attribute => ORM.knex.schema.hasColumn(table, attribute))
);
const columnsToAdd = {};
// Get columns to add
columnsExist.forEach((columnExist, index) => {
const attribute = attributes[columns[index]];
if (!columnExist) {
columnsToAdd[columns[index]] = attribute;
}
});
// Generate and execute query to add missing column
if (Object.keys(columnsToAdd).length > 0) {
await ORM.knex.schema.table(table, tbl => {
createColumns(tbl, columnsToAdd, { tableExists });
});
}
// Generate indexes for new attributes.
await generateIndexes(table, columnsToAdd);
let previousAttributes;
try {
previousAttributes = JSON.parse(
(await StrapiConfigs.forge({
key: `db_model_${table}`,
}).fetch()).toJSON().value
);
} catch (err) {
await storeTable(table, attributes);
previousAttributes = JSON.parse(
(await StrapiConfigs.forge({
key: `db_model_${table}`,
}).fetch()).toJSON().value
);
}
if (JSON.stringify(previousAttributes) === JSON.stringify(attributes)) {
return;
}
if (definition.client === 'sqlite3') {
const tmpTable = `tmp_${table}`;
const rebuildTable = async trx => {
await trx.schema.renameTable(table, tmpTable);
// drop possible conflicting indexes
await Promise.all(
columns.map(key =>
trx.raw('DROP INDEX IF EXISTS ??', uniqueColName(table, key))
)
);
// create the table
await createTable(table, { trx });
const attrs = Object.keys(attributes).filter(attribute =>
getType({
definition,
attribute: attributes[attribute],
name: attribute,
})
);
const allAttrs = ['id', ...attrs];
await trx.raw(`INSERT INTO ?? (${allAttrs.join(', ')}) ??`, [
table,
trx.select(allAttrs).from(tmpTable),
]);
await trx.schema.dropTableIfExists(tmpTable);
};
try {
await ORM.knex.transaction(trx => rebuildTable(trx));
await generateIndexes(table);
} catch (err) {
if (err.message.includes('UNIQUE constraint failed')) {
strapi.log.error(
`Unique constraint fails, make sure to update your data and restart to apply the unique constraint.\n\t- ${err.stack}`
);
} else {
strapi.log.error(`Migration failed`);
strapi.log.error(err);
}
return false;
}
} else {
const columnsToAlter = columns.filter(
key =>
JSON.stringify(previousAttributes[key]) !==
JSON.stringify(attributes[key])
);
const alterTable = async trx => {
await Promise.all(
columnsToAlter.map(col => {
return ORM.knex.schema
.alterTable(table, tbl => {
tbl.dropUnique(col, uniqueColName(table, col));
})
.catch(() => {});
})
);
await trx.schema.alterTable(table, tbl => {
alterColumns(tbl, _.pick(attributes, columnsToAlter), {
tableExists,
});
});
};
try {
await ORM.knex.transaction(trx => alterTable(trx));
} catch (err) {
if (err.code === '23505' && definition.client === 'pg') {
strapi.log.error(
`Unique constraint fails, make sure to update your data and restart to apply the unique constraint.\n\t- ${err.message}\n\t- ${err.detail}`
);
} else if (definition.client === 'mysql' && err.errno === 1062) {
strapi.log.error(
`Unique constraint fails, make sure to update your data and restart to apply the unique constraint.\n\t- ${err.sqlMessage}`
);
} else {
strapi.log.error(`Migration failed`);
strapi.log.error(err);
}
return false;
}
}
await storeTable(table, attributes);
};
// Add created_at and updated_at field if timestamp option is true
if (hasTimestamps) {
definition.attributes[createAtCol] = {
type: 'timestamp',
};
definition.attributes[updatedAtCol] = {
type: 'timestampUpdate',
};
}
// Save all attributes (with timestamps)
model.allAttributes = _.clone(definition.attributes);
// Equilize tables
if (connection.options && connection.options.autoMigration !== false) {
await createOrUpdateTable(loadedModel.tableName, definition.attributes);
}
// Equilize polymorphic releations
const morphRelations = definition.associations.filter(association => {
return association.nature.toLowerCase().includes('morphto');
});
for (const morphRelation of morphRelations) {
const attributes = {
[`${loadedModel.tableName}_id`]: {
type: definition.primaryKeyType,
},
[`${morphRelation.alias}_id`]: {
type: definition.primaryKeyType,
},
[`${morphRelation.alias}_type`]: {
type: 'text',
},
[definition.attributes[morphRelation.alias].filter]: {
type: 'text',
},
};
if (connection.options && connection.options.autoMigration !== false) {
await createOrUpdateTable(`${loadedModel.tableName}_morph`, attributes);
}
}
// Equilize many to many releations
const manyRelations = definition.associations.filter(({ nature }) =>
['manyToMany', 'manyWay'].includes(nature)
);
for (const manyRelation of manyRelations) {
const { plugin, collection, via, dominant, alias } = manyRelation;
if (dominant) {
const targetCollection = plugin
? strapi.plugins[plugin].models[collection]
: strapi.models[collection];
const targetAttr = via
? targetCollection.attributes[via]
: {
attribute: singular(definition.collectionName),
column: definition.primaryKey,
};
const defAttr = definition.attributes[alias];
const attributes = {
[`${targetAttr.attribute}_${targetAttr.column}`]: {
type: targetCollection.primaryKeyType,
},
[`${defAttr.attribute}_${defAttr.column}`]: {
type: definition.primaryKeyType,
},
};
const table = manyRelation.tableCollectionName;
await createOrUpdateTable(table, attributes);
}
}
// Remove from attributes (auto handled by bookshlef and not displayed on ctb)
if (hasTimestamps) {
delete definition.attributes[createAtCol];
delete definition.attributes[updatedAtCol];
}
};
const getType = ({ definition, attribute, name, tableExists = false }) => {
const { client } = definition;
if (!attribute.type) {
// Add integer value if there is a relation
const relation = definition.associations.find(association => {
return association.alias === name;
});
switch (relation.nature) {
case 'oneToOne':
case 'manyToOne':
case 'oneWay':
return definition.primaryKeyType;
default:
return null;
}
}
switch (attribute.type) {
case 'uuid':
return client === 'pg' ? 'uuid' : 'varchar(36)';
case 'richtext':
case 'text':
return client === 'pg' ? 'text' : 'longtext';
case 'json':
return client === 'pg' ? 'jsonb' : 'longtext';
case 'string':
case 'enumeration':
case 'password':
case 'email':
return 'varchar(255)';
case 'integer':
return client === 'pg' ? 'integer' : 'int';
case 'biginteger':
if (client === 'sqlite3') return 'bigint(53)'; // no choice until the sqlite3 package supports returning strings for big integers
return 'bigint';
case 'float':
return client === 'pg' ? 'double precision' : 'double';
case 'decimal':
return 'decimal(10,2)';
// TODO: split time types as they should be different
case 'date':
case 'time':
case 'datetime':
case 'timestamp':
if (client === 'pg') {
return 'timestamp with time zone';
} else if (client === 'sqlite3' && tableExists) {
return 'timestamp DEFAULT NULL';
}
return 'timestamp DEFAULT CURRENT_TIMESTAMP';
case 'timestampUpdate':
switch (client) {
case 'pg':
return 'timestamp with time zone';
case 'sqlite3':
if (tableExists) {
return 'timestamp DEFAULT NULL';
}
return 'timestamp DEFAULT CURRENT_TIMESTAMP';
default:
return 'timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
}
case 'boolean':
return 'boolean';
default:
}
};
const storeTable = async (table, attributes) => {
const existTable = await StrapiConfigs.forge({
key: `db_model_${table}`,
}).fetch();
if (existTable) {
return await StrapiConfigs.forge({
id: existTable.id,
}).save({
value: JSON.stringify(attributes),
});
}
await StrapiConfigs.forge({
key: `db_model_${table}`,
type: 'object',
value: JSON.stringify(attributes),
}).save();
};
const defaultIdType = {
mysql: 'INT AUTO_INCREMENT NOT NULL PRIMARY KEY',
pg: 'SERIAL NOT NULL PRIMARY KEY',
sqlite3: 'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL',
};
const getIdType = definition => {
if (definition.primaryKeyType === 'uuid' && definition.client === 'pg') {
return 'uuid NOT NULL DEFAULT uuid_generate_v4() NOT NULL PRIMARY KEY';
}
if (definition.primaryKeyType !== 'integer') {
const type = getType({
definition,
attribute: {
type: definition.primaryKeyType,
},
});
return `${type} NOT NULL PRIMARY KEY`;
}
return defaultIdType[definition.client];
};
const uniqueColName = (table, key) => `${table}_${key}_unique`;