313 lines
8.2 KiB
TypeScript
313 lines
8.2 KiB
TypeScript
import { Injectable, Logger } from '@nestjs/common';
|
|
import { Knex } from 'knex';
|
|
import { ObjectDefinition } from '../models/object-definition.model';
|
|
import { FieldDefinition } from '../models/field-definition.model';
|
|
|
|
@Injectable()
|
|
export class SchemaManagementService {
|
|
private readonly logger = new Logger(SchemaManagementService.name);
|
|
|
|
/**
|
|
* Create a physical table for an object definition
|
|
*/
|
|
async createObjectTable(
|
|
knex: Knex,
|
|
objectDefinition: ObjectDefinition,
|
|
fields: FieldDefinition[],
|
|
) {
|
|
const tableName = this.getTableName(
|
|
objectDefinition.apiName,
|
|
objectDefinition.label,
|
|
objectDefinition.pluralLabel,
|
|
);
|
|
|
|
// Check if table already exists
|
|
const exists = await knex.schema.hasTable(tableName);
|
|
if (exists) {
|
|
throw new Error(`Table ${tableName} already exists`);
|
|
}
|
|
|
|
await knex.schema.createTable(tableName, (table) => {
|
|
// Standard fields
|
|
table.uuid('id').primary().defaultTo(knex.raw('(UUID())'));
|
|
table.timestamps(true, true);
|
|
|
|
// Custom fields from field definitions
|
|
for (const field of fields) {
|
|
this.addFieldColumn(table, field);
|
|
}
|
|
});
|
|
|
|
this.logger.log(`Created table: ${tableName}`);
|
|
}
|
|
|
|
/**
|
|
* Add a new field to an existing object table
|
|
*/
|
|
async addFieldToTable(
|
|
knex: Knex,
|
|
objectApiName: string,
|
|
field: FieldDefinition,
|
|
objectLabel?: string,
|
|
pluralLabel?: string,
|
|
) {
|
|
const tableName = this.getTableName(objectApiName, objectLabel, pluralLabel);
|
|
|
|
await knex.schema.alterTable(tableName, (table) => {
|
|
this.addFieldColumn(table, field);
|
|
});
|
|
|
|
this.logger.log(`Added field ${field.apiName} to table ${tableName}`);
|
|
}
|
|
|
|
/**
|
|
* Remove a field from an existing object table
|
|
*/
|
|
async removeFieldFromTable(
|
|
knex: Knex,
|
|
objectApiName: string,
|
|
fieldApiName: string,
|
|
objectLabel?: string,
|
|
pluralLabel?: string,
|
|
) {
|
|
const tableName = this.getTableName(objectApiName, objectLabel, pluralLabel);
|
|
|
|
await knex.schema.alterTable(tableName, (table) => {
|
|
table.dropColumn(fieldApiName);
|
|
});
|
|
|
|
this.logger.log(`Removed field ${fieldApiName} from table ${tableName}`);
|
|
}
|
|
|
|
/**
|
|
* Alter a field in an existing object table
|
|
* Handles safe updates like changing NOT NULL or constraints
|
|
* Warns about potentially destructive operations
|
|
*/
|
|
async alterFieldInTable(
|
|
knex: Knex,
|
|
objectApiName: string,
|
|
fieldApiName: string,
|
|
field: FieldDefinition,
|
|
objectLabel?: string,
|
|
pluralLabel?: string,
|
|
options?: {
|
|
skipTypeChange?: boolean; // Skip if type change would lose data
|
|
},
|
|
) {
|
|
const tableName = this.getTableName(objectApiName, objectLabel, pluralLabel);
|
|
const skipTypeChange = options?.skipTypeChange ?? true;
|
|
|
|
await knex.schema.alterTable(tableName, (table) => {
|
|
// Drop the existing column and recreate with new definition
|
|
// Note: This approach works for metadata changes, but type changes may need data migration
|
|
table.dropColumn(fieldApiName);
|
|
});
|
|
|
|
// Recreate the column with new definition
|
|
await knex.schema.alterTable(tableName, (table) => {
|
|
this.addFieldColumn(table, field);
|
|
});
|
|
|
|
this.logger.log(`Altered field ${fieldApiName} in table ${tableName}`);
|
|
}
|
|
|
|
/**
|
|
* Drop an object table
|
|
*/
|
|
async dropObjectTable(knex: Knex, objectApiName: string, objectLabel?: string, pluralLabel?: string) {
|
|
const tableName = this.getTableName(objectApiName, objectLabel, pluralLabel);
|
|
|
|
await knex.schema.dropTableIfExists(tableName);
|
|
|
|
this.logger.log(`Dropped table: ${tableName}`);
|
|
}
|
|
|
|
/**
|
|
* Add a field column to a table builder
|
|
*/
|
|
private addFieldColumn(
|
|
table: Knex.CreateTableBuilder | Knex.AlterTableBuilder,
|
|
field: FieldDefinition,
|
|
) {
|
|
const columnName = field.apiName;
|
|
|
|
let column: Knex.ColumnBuilder;
|
|
|
|
switch (field.type) {
|
|
// Text types
|
|
case 'String':
|
|
case 'TEXT':
|
|
case 'EMAIL':
|
|
case 'PHONE':
|
|
case 'URL':
|
|
column = table.string(columnName, field.length || 255);
|
|
break;
|
|
|
|
case 'Text':
|
|
case 'LONG_TEXT':
|
|
column = table.text(columnName);
|
|
break;
|
|
|
|
case 'PICKLIST':
|
|
case 'MULTI_PICKLIST':
|
|
column = table.string(columnName, 255);
|
|
break;
|
|
|
|
// Numeric types
|
|
case 'Number':
|
|
case 'NUMBER':
|
|
case 'CURRENCY':
|
|
case 'PERCENT':
|
|
if (field.scale && field.scale > 0) {
|
|
column = table.decimal(
|
|
columnName,
|
|
field.precision || 10,
|
|
field.scale,
|
|
);
|
|
} else {
|
|
column = table.integer(columnName);
|
|
}
|
|
break;
|
|
|
|
case 'Boolean':
|
|
case 'BOOLEAN':
|
|
column = table.boolean(columnName).defaultTo(false);
|
|
break;
|
|
|
|
// Date types
|
|
case 'Date':
|
|
case 'DATE':
|
|
column = table.date(columnName);
|
|
break;
|
|
|
|
case 'DateTime':
|
|
case 'DATE_TIME':
|
|
column = table.datetime(columnName);
|
|
break;
|
|
|
|
case 'TIME':
|
|
column = table.time(columnName);
|
|
break;
|
|
|
|
// Relationship types
|
|
case 'Reference':
|
|
case 'LOOKUP':
|
|
column = table.uuid(columnName);
|
|
if (field.referenceObject) {
|
|
const refTableName = this.getTableName(field.referenceObject);
|
|
column.references('id').inTable(refTableName).onDelete('SET NULL');
|
|
}
|
|
break;
|
|
|
|
// Email (legacy)
|
|
case 'Email':
|
|
column = table.string(columnName, 255);
|
|
break;
|
|
|
|
// Phone (legacy)
|
|
case 'Phone':
|
|
column = table.string(columnName, 50);
|
|
break;
|
|
|
|
// Url (legacy)
|
|
case 'Url':
|
|
column = table.string(columnName, 255);
|
|
break;
|
|
|
|
// File types
|
|
case 'FILE':
|
|
case 'IMAGE':
|
|
column = table.text(columnName); // Store file path or URL
|
|
break;
|
|
|
|
// JSON
|
|
case 'Json':
|
|
case 'JSON':
|
|
column = table.json(columnName);
|
|
break;
|
|
|
|
default:
|
|
throw new Error(`Unsupported field type: ${field.type}`);
|
|
}
|
|
|
|
if (field.isRequired) {
|
|
column.notNullable();
|
|
} else {
|
|
column.nullable();
|
|
}
|
|
|
|
if (field.isUnique) {
|
|
column.unique();
|
|
}
|
|
|
|
if (field.defaultValue) {
|
|
column.defaultTo(field.defaultValue);
|
|
}
|
|
|
|
return column;
|
|
}
|
|
|
|
/**
|
|
* Convert object API name to table name (convert to snake_case, pluralize)
|
|
*/
|
|
private getTableName(apiName: string, objectLabel?: string, pluralLabel?: string): string {
|
|
const toSnakePlural = (source: string): string => {
|
|
const cleaned = source.replace(/[\s-]+/g, '_');
|
|
const snake = cleaned
|
|
.replace(/([a-z0-9])([A-Z])/g, '$1_$2')
|
|
.replace(/__+/g, '_')
|
|
.toLowerCase()
|
|
.replace(/^_/, '');
|
|
|
|
if (snake.endsWith('y')) return `${snake.slice(0, -1)}ies`;
|
|
if (snake.endsWith('s')) return snake;
|
|
return `${snake}s`;
|
|
};
|
|
|
|
const fromApi = toSnakePlural(apiName);
|
|
const fromLabel = objectLabel ? toSnakePlural(objectLabel) : null;
|
|
const fromPlural = pluralLabel ? toSnakePlural(pluralLabel) : null;
|
|
|
|
if (fromLabel && fromLabel.includes('_') && !fromApi.includes('_')) {
|
|
return fromLabel;
|
|
}
|
|
if (fromPlural && fromPlural.includes('_') && !fromApi.includes('_')) {
|
|
return fromPlural;
|
|
}
|
|
|
|
if (fromLabel && fromLabel !== fromApi) return fromLabel;
|
|
if (fromPlural && fromPlural !== fromApi) return fromPlural;
|
|
|
|
return fromApi;
|
|
}
|
|
|
|
/**
|
|
* Validate field definition before creating column
|
|
*/
|
|
validateFieldDefinition(field: FieldDefinition) {
|
|
if (!field.apiName || !field.label || !field.type) {
|
|
throw new Error('Field must have apiName, label, and type');
|
|
}
|
|
|
|
// Validate field name (alphanumeric + underscore, starts with letter)
|
|
if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(field.apiName)) {
|
|
throw new Error(`Invalid field name: ${field.apiName}`);
|
|
}
|
|
|
|
// Validate reference field has referenceObject
|
|
if (field.type === 'Reference' && !field.referenceObject) {
|
|
throw new Error('Reference field must specify referenceObject');
|
|
}
|
|
|
|
// Validate numeric fields
|
|
if (field.type === 'Number') {
|
|
if (field.scale && field.scale > 0 && !field.precision) {
|
|
throw new Error('Decimal fields must specify precision');
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|