@quereus/quereus 0.7.3 → 0.7.5

package/src/schema/schema-differ.ts

@@ -1,214 +0,0 @@
-import type { SchemaCatalog } from './catalog.js';
-import type * as AST from '../parser/ast.js';
-import { createTableToString, createViewToString, createIndexToString } from '../util/ast-stringify.js';
-
-/**
- * Represents the difference between a declared schema and actual database state
- */
-export interface SchemaDiff {
-	tablesToCreate: string[];
-	tablesToDrop: string[];
-	tablesToAlter: TableAlterDiff[];
-	viewsToCreate: string[];
-	viewsToDrop: string[];
-	indexesToCreate: string[];
-	indexesToDrop: string[];
-	assertionsToCreate: string[];
-	assertionsToDrop: string[];
-}
-
-export interface TableAlterDiff {
-	tableName: string;
-	columnsToAdd: string[];
-	columnsToDrop: string[];
-}
-
-/**
- * Computes the difference between declared schema and actual catalog
- */
-export function computeSchemaDiff(
-	declaredSchema: AST.DeclareSchemaStmt,
-	actualCatalog: SchemaCatalog
-): SchemaDiff {
-	const diff: SchemaDiff = {
-		tablesToCreate: [],
-		tablesToDrop: [],
-		tablesToAlter: [],
-		viewsToCreate: [],
-		viewsToDrop: [],
-		indexesToCreate: [],
-		indexesToDrop: [],
-		assertionsToCreate: [],
-		assertionsToDrop: []
-	};
-
-	const targetSchemaName = actualCatalog.schemaName;
-
-	// Build maps of declared items
-	const declaredTables = new Map<string, AST.DeclaredTable>();
-	const declaredViews = new Map<string, AST.DeclaredView>();
-	const declaredIndexes = new Map<string, AST.DeclaredIndex>();
-
-	for (const item of declaredSchema.items) {
-		switch (item.type) {
-			case 'declaredTable':
-				declaredTables.set(item.tableStmt.table.name.toLowerCase(), item);
-				break;
-			case 'declaredView':
-				declaredViews.set(item.viewStmt.view.name.toLowerCase(), item);
-				break;
-			case 'declaredIndex':
-				declaredIndexes.set(item.indexStmt.index.name.toLowerCase(), item);
-				break;
-		}
-	}
-
-	// Build maps of actual items
-	const actualTables = new Map(actualCatalog.tables.map(t => [t.name.toLowerCase(), t]));
-	const actualViews = new Map(actualCatalog.views.map(v => [v.name.toLowerCase(), v]));
-	const actualIndexes = new Map(actualCatalog.indexes.map(i => [i.name.toLowerCase(), i]));
-
-	// Find tables to create (in declared but not in actual)
-	for (const [name, declaredTable] of declaredTables) {
-		if (!actualTables.has(name)) {
-			// Qualify with schema if not main
-			const tableStmt = declaredTable.tableStmt;
-			if (targetSchemaName && targetSchemaName !== 'main' && !tableStmt.table.schema) {
-				const qualifiedStmt: AST.CreateTableStmt = {
-					...tableStmt,
-					table: {
-						...tableStmt.table,
-						schema: targetSchemaName
-					}
-				};
-				diff.tablesToCreate.push(createTableToString(qualifiedStmt));
-			} else {
-				diff.tablesToCreate.push(createTableToString(tableStmt));
-			}
-		} else {
-			// Table exists - check if it needs alteration
-			const alterDiff = computeTableAlterDiff(declaredTable, actualTables.get(name)!);
-			if (alterDiff.columnsToAdd.length > 0 || alterDiff.columnsToDrop.length > 0) {
-				diff.tablesToAlter.push(alterDiff);
-			}
-		}
-	}
-
-	// Find tables to drop (in actual but not in declared)
-	for (const [name] of actualTables) {
-		if (!declaredTables.has(name)) {
-			diff.tablesToDrop.push(name);
-		}
-	}
-
-	// Find views to create/drop
-	for (const [name, declaredView] of declaredViews) {
-		if (!actualViews.has(name)) {
-			// Generate proper view DDL using AST stringifier
-			diff.viewsToCreate.push(createViewToString(declaredView.viewStmt));
-		}
-	}
-
-	for (const [name] of actualViews) {
-		if (!declaredViews.has(name)) {
-			diff.viewsToDrop.push(name);
-		}
-	}
-
-	// Find indexes to create/drop
-	for (const [name, declaredIndex] of declaredIndexes) {
-		if (!actualIndexes.has(name)) {
-			// Generate proper index DDL using AST stringifier
-			diff.indexesToCreate.push(createIndexToString(declaredIndex.indexStmt));
-		}
-	}
-
-	for (const [name] of actualIndexes) {
-		if (!declaredIndexes.has(name)) {
-			diff.indexesToDrop.push(name);
-		}
-	}
-
-	return diff;
-}
-
-function computeTableAlterDiff(
-	declaredTable: AST.DeclaredTable,
-	actualTable: { name: string; columns: Array<{ name: string }> }
-): TableAlterDiff {
-	const diff: TableAlterDiff = {
-		tableName: declaredTable.tableStmt.table.name,
-		columnsToAdd: [],
-		columnsToDrop: []
-	};
-
-	const declaredColumns = new Set(
-		declaredTable.tableStmt.columns.map(c => c.name.toLowerCase())
-	);
-	const actualColumns = new Set(
-		actualTable.columns.map(c => c.name.toLowerCase())
-	);
-
-	// Find columns to add
-	for (const col of declaredTable.tableStmt.columns) {
-		if (!actualColumns.has(col.name.toLowerCase())) {
-			diff.columnsToAdd.push(col.name);
-		}
-	}
-
-	// Find columns to drop
-	for (const col of actualTable.columns) {
-		if (!declaredColumns.has(col.name.toLowerCase())) {
-			diff.columnsToDrop.push(col.name);
-		}
-	}
-
-	return diff;
-}
-
-/**
- * Serializes a schema diff to JSON string
- */
-export function serializeSchemaDiff(diff: SchemaDiff): string {
-	return JSON.stringify(diff, null, 2);
-}
-
-/**
- * Generates migration DDL statements from a schema diff
- */
-export function generateMigrationDDL(diff: SchemaDiff, schemaName?: string): string[] {
-	const statements: string[] = [];
-	const schemaPrefix = (schemaName && schemaName !== 'main') ? `${schemaName}.` : '';
-
-	// Drop items first (reverse order)
-	for (const tableName of diff.tablesToDrop) {
-		statements.push(`DROP TABLE IF EXISTS ${schemaPrefix}${tableName}`);
-	}
-
-	for (const viewName of diff.viewsToDrop) {
-		statements.push(`DROP VIEW IF EXISTS ${schemaPrefix}${viewName}`);
-	}
-
-	for (const indexName of diff.indexesToDrop) {
-		statements.push(`DROP INDEX IF EXISTS ${schemaPrefix}${indexName}`);
-	}
-
-	// Create new items
-	statements.push(...diff.tablesToCreate);
-	statements.push(...diff.viewsToCreate);
-	statements.push(...diff.indexesToCreate);
-
-	// Alter existing tables
-	for (const alter of diff.tablesToAlter) {
-		for (const colName of alter.columnsToAdd) {
-			statements.push(`ALTER TABLE ${schemaPrefix}${alter.tableName} ADD COLUMN ${colName}`);
-		}
-		for (const colName of alter.columnsToDrop) {
-			statements.push(`ALTER TABLE ${schemaPrefix}${alter.tableName} DROP COLUMN ${colName}`);
-		}
-	}
-
-	return statements;
-}
-
-

package/src/schema/schema-hasher.ts

@@ -1,26 +0,0 @@
-import type * as AST from '../parser/ast.js';
-import { generateDeclaredDDL } from './catalog.js';
-import { fnv1aHash, toBase64Url } from '../util/hash.js';
-
-/**
- * Computes a hash of a declared schema for versioning
- */
-export function computeSchemaHash(declaredSchema: AST.DeclareSchemaStmt): string {
-	// Generate canonical DDL representation
-	const ddlStatements = generateDeclaredDDL(declaredSchema);
-	const canonicalText = ddlStatements.join('\n');
-
-	// Compute hash using FNV-1a algorithm and encode as base64url
-	const hashBytes = fnv1aHash(canonicalText);
-	return toBase64Url(hashBytes);
-}
-
-/**
- * Computes a short hash (first 8 characters) for display
- */
-export function computeShortSchemaHash(declaredSchema: AST.DeclareSchemaStmt): string {
-	const fullHash = computeSchemaHash(declaredSchema);
-	return fullHash.substring(0, 8);
-}
-
-

package/src/schema/schema.ts

@@ -1,222 +0,0 @@
-import type { TableSchema } from './table.js';
-import type { FunctionSchema } from './function.js';
-import { getFunctionKey } from './function.js';
-import type { ViewSchema } from './view.js';
-import { quereusError, QuereusError } from '../common/errors.js';
-import { createLogger } from '../common/logger.js';
-import type { IntegrityAssertionSchema } from './assertion.js';
-
-const log = createLogger('schema:schema');
-
-/**
- * Represents a single database schema (e.g., "main", "temp").
- * Contains collections of tables, functions, etc. defined within that schema.
- */
-export class Schema {
-	public readonly name: string;
-	private tables: Map<string, TableSchema> = new Map();
-	private functions: Map<string, FunctionSchema> = new Map();
-	private views: Map<string, ViewSchema> = new Map();
-	private assertions: Map<string, IntegrityAssertionSchema> = new Map();
-
-	/**
-	 * Creates a new schema instance
-	 *
-	 * @param name The schema name (e.g. "main", "temp")
-	 */
-	constructor(name: string) {
-		this.name = name;
-	}
-
-	/**
-	 * Retrieves a table schema definition
-	 *
-	 * @param tableName The name of the table (case-insensitive)
-	 * @returns The table schema or undefined if not found
-	 */
-	getTable(tableName: string): TableSchema | undefined {
-		return this.tables.get(tableName.toLowerCase());
-	}
-
-	/**
-	 * Adds or replaces a table definition in the schema
-	 *
-	 * @param table The table schema object
-	 * @throws QuereusError if a view with the same name exists
-	 */
-	addTable(table: TableSchema): void {
-		// Ensure no view conflict
-		if (this.views.has(table.name.toLowerCase())) {
-			throw new QuereusError(`Schema '${this.name}': Cannot add table '${table.name}', a view with the same name already exists.`);
-		}
-		this.tables.set(table.name.toLowerCase(), table);
-	}
-
-	/**
-	 * Returns an iterator over all tables in the schema
-	 *
-	 * @returns Iterator of table schemas
-	 */
-	getAllTables(): IterableIterator<TableSchema> {
-		return this.tables.values();
-	}
-
-	/**
-	 * Removes a table definition from the schema
-	 *
-	 * @param tableName The name of the table to remove
-	 * @returns true if found and removed, false otherwise
-	 */
-	removeTable(tableName: string): boolean {
-		const key = tableName.toLowerCase();
-		const exists = this.tables.has(key);
-		if (exists) {
-			this.tables.delete(key);
-		}
-		return exists;
-	}
-
-	/**
-	 * Clears all tables (does not call VTable disconnect/destroy)
-	 */
-	clearTables(): void {
-		this.tables.clear();
-	}
-
-	/**
-	 * Adds or replaces a view definition in the schema
-	 *
-	 * @param view The view schema to add
-	 * @throws Error if view's schema name doesn't match or a table with same name exists
-	 */
-	addView(view: ViewSchema): void {
-		if (view.schemaName !== this.name) {
-			quereusError(`View ${view.name} has wrong schema name ${view.schemaName}, expected ${this.name}`);
-		}
-		if (this.tables.has(view.name.toLowerCase())) {
-			throw new QuereusError(`Schema '${this.name}': Cannot add view '${view.name}', a table with the same name already exists.`);
-		}
-		this.views.set(view.name.toLowerCase(), view);
-		log(`Added/Updated view '%s' in schema '%s'`, view.name, this.name);
-	}
-
-	/**
-	 * Gets a view definition by name (case-insensitive)
-	 *
-	 * @param viewName The view name to look up
-	 * @returns The view schema or undefined if not found
-	 */
-	getView(viewName: string): ViewSchema | undefined {
-		return this.views.get(viewName.toLowerCase());
-	}
-
-	/**
-	 * Returns an iterator over all views in the schema
-	 *
-	 * @returns Iterator of view schemas
-	 */
-	getAllViews(): IterableIterator<ViewSchema> {
-		return this.views.values();
-	}
-
-	/**
-	 * Removes a view definition from the schema
-	 *
-	 * @param viewName The name of the view to remove
-	 * @returns true if found and removed, false otherwise
-	 */
-	removeView(viewName: string): boolean {
-		const key = viewName.toLowerCase();
-		const exists = this.views.has(key);
-		if (exists) {
-			log(`Removed view '%s' from schema '%s'`, viewName, this.name);
-			this.views.delete(key);
-		}
-		return exists;
-	}
-
-	/**
-	 * Clears all views
-	 */
-	clearViews(): void {
-		this.views.clear();
-	}
-
-	/** Assertions */
-	addAssertion(assertion: IntegrityAssertionSchema): void {
-		this.assertions.set(assertion.name.toLowerCase(), assertion);
-		log(`Added/Updated assertion '%s' in schema '%s'`, assertion.name, this.name);
-	}
-
-	getAssertion(name: string): IntegrityAssertionSchema | undefined {
-		return this.assertions.get(name.toLowerCase());
-	}
-
-	getAllAssertions(): IterableIterator<IntegrityAssertionSchema> {
-		return this.assertions.values();
-	}
-
-	removeAssertion(name: string): boolean {
-		const key = name.toLowerCase();
-		const existed = this.assertions.delete(key);
-		if (existed) log(`Removed assertion '%s' from schema '%s'`, name, this.name);
-		return existed;
-	}
-
-	/**
-	 * Adds or replaces a function definition in the schema
-	 * Calls the destructor for any existing function being replaced
-	 *
-	 * @param func The function schema to add
-	 */
-	addFunction(func: FunctionSchema): void {
-		const key = getFunctionKey(func.name, func.numArgs);
-		this.functions.set(key, func);
-		log(`Added/Updated function '%s' in schema '%s'`, `${func.name}/${func.numArgs}`, this.name);
-	}
-
-	/**
-	 * Gets a function definition by name and argument count (case-insensitive name)
-	 * First checks for exact argument count match, then tries variable args (-1)
-	 *
-	 * @param name The function name
-	 * @param numArgs The number of arguments
-	 * @returns The function schema or undefined if not found
-	 */
-	getFunction(name: string, numArgs: number): FunctionSchema | undefined {
-		const key = getFunctionKey(name, numArgs);
-		const varArgsKey = getFunctionKey(name, -1);
-		return this.functions.get(key) ?? this.functions.get(varArgsKey);
-	}
-
-	/**
-	 * @internal Returns iterator over managed functions
-	 */
-	_getAllFunctions(): IterableIterator<FunctionSchema> {
-		return this.functions.values();
-	}
-
-	/**
-	 * Removes a function definition, calling its destructor if needed
-	 *
-	 * @param name The function name
-	 * @param numArgs The number of arguments
-	 * @returns true if found and removed, false otherwise
-	 */
-	removeFunction(name: string, numArgs: number): boolean {
-		const key = getFunctionKey(name, numArgs);
-		const func = this.functions.get(key);
-		if (func) {
-			log(`Removed function '%s' from schema '%s'`, `${name}/${numArgs}`, this.name);
-			return this.functions.delete(key);
-		}
-		return false;
-	}
-
-	/**
-	 * Clears all functions, calling destructors if needed
-	 */
-	clearFunctions(): void {
-		this.functions.clear();
-	}
-}