rawsql-ts
Version:
High-performance SQL parser and AST analyzer written in TypeScript. Provides fast parsing and advanced transformation capabilities.
156 lines • 5.35 kB
JavaScript
;
/**
* Central schema management utility for rawsql-ts.
* Converts user-defined table definitions into resolvers consumed by collectors and builders.
*
* @example
* ```typescript
* const manager = new SchemaManager({
* users: {
* name: 'users',
* columns: {
* id: { name: 'id', isPrimaryKey: true },
* email: { name: 'email' }
* }
* }
* });
*
* const resolver = manager.createTableColumnResolver();
* const collector = new SchemaCollector(resolver);
* const schemas = collector.collect(SelectQueryParser.parse('SELECT * FROM users'));
* ```
* Related tests: packages/core/tests/transformers/SchemaCollector.test.ts
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.SchemaManager = void 0;
exports.createSchemaManager = createSchemaManager;
exports.createTableColumnResolver = createTableColumnResolver;
// === Schema Manager Class ===
/**
* Central schema management utility for rawsql-ts
* Converts user-defined schemas to resolvers consumed by schema-aware utilities
*/
class SchemaManager {
constructor(schemas) {
this.schemas = schemas;
this.validateSchemas();
}
/**
* Validate schema definitions for consistency
* Ensures each table has a primary key (required for UPDATE/DELETE operations)
* and validates relationship references
*/
validateSchemas() {
const tableNames = Object.keys(this.schemas);
const errors = [];
// Validate each table
Object.entries(this.schemas).forEach(([tableName, table]) => {
var _a;
// Check primary key exists (required for UPDATE/DELETE WHERE conditions)
const primaryKeys = Object.entries(table.columns)
.filter(([_, col]) => col.isPrimaryKey)
.map(([name, _]) => name);
if (primaryKeys.length === 0) {
errors.push(`Table '${tableName}' has no primary key defined`);
}
// Validate foreign key references
(_a = table.relationships) === null || _a === void 0 ? void 0 : _a.forEach(rel => {
if (!tableNames.includes(rel.table)) {
errors.push(`Table '${tableName}' references unknown table '${rel.table}' in relationship`);
}
});
});
if (errors.length > 0) {
throw new Error(`Schema validation failed:\\n${errors.join('\\n')}`);
}
}
/**
* Get table column names for SqlParamInjector TableColumnResolver
* @param tableName Name of the table
* @returns Array of column names
*/
getTableColumns(tableName) {
const table = this.schemas[tableName];
if (!table) {
return [];
}
return Object.keys(table.columns);
}
/**
* Create TableColumnResolver function for SqlParamInjector
* @returns Function compatible with SqlParamInjector
*/
createTableColumnResolver() {
return (tableName) => this.getTableColumns(tableName);
}
/**
* Get all table names in the schema
* @returns Array of table names
*/
getTableNames() {
return Object.keys(this.schemas);
}
/**
* Get table definition by name
* @param tableName Name of the table
* @returns Table definition or undefined
*/
getTable(tableName) {
return this.schemas[tableName];
}
/**
* Get primary key column name for a table
* Used by QueryBuilder.buildUpdateQuery for WHERE clause conditions
* @param tableName Name of the table
* @returns Primary key column name or undefined
*/
getPrimaryKey(tableName) {
const table = this.schemas[tableName];
if (!table)
return undefined;
const primaryKeyEntry = Object.entries(table.columns)
.find(([_, col]) => col.isPrimaryKey);
return primaryKeyEntry ? primaryKeyEntry[0] : undefined;
}
/**
* Get foreign key relationships for a table
* @param tableName Name of the table
* @returns Array of foreign key relationships
*/
getForeignKeys(tableName) {
const table = this.schemas[tableName];
if (!table)
return [];
const foreignKeys = [];
Object.entries(table.columns).forEach(([columnName, column]) => {
if (column.foreignKey) {
foreignKeys.push({
column: columnName,
referencedTable: column.foreignKey.table,
referencedColumn: column.foreignKey.column
});
}
});
return foreignKeys;
}
}
exports.SchemaManager = SchemaManager;
// === Convenience Functions ===
/**
* Create a SchemaManager instance from schema definitions
* @param schemas Schema registry object
* @returns SchemaManager instance
*/
function createSchemaManager(schemas) {
return new SchemaManager(schemas);
}
/**
* Create TableColumnResolver function from schema definitions
* @param schemas Schema registry object
* @returns TableColumnResolver function for SqlParamInjector
*/
function createTableColumnResolver(schemas) {
const manager = new SchemaManager(schemas);
return manager.createTableColumnResolver();
}
//# sourceMappingURL=SchemaManager.js.map