pg-migration-engine 0.1.0

package/src/behavioral/behavioral-applier.js

@@ -0,0 +1,374 @@
+/**
+ * Behavioral Applier - Apply behavioral changes after structural changes
+ * Order: Functions → Views → Materialized Views → Triggers → Policies → Rules → Event Triggers
+ */
+
+export class BehavioralApplier {
+  /**
+   * @param {import('pg').Pool} pool
+   */
+  constructor(pool) {
+    this.pool = pool;
+  }
+
+  /**
+   * Get ordered changes for behavioral objects
+   * @param {Array} changes
+   * @returns {Array} Ordered behavioral changes
+   */
+  getOrder(changes) {
+    const order = [
+      'CREATE_FUNCTION',
+      'REPLACE_FUNCTION',
+      'RECREATE_FUNCTION',
+      'CREATE_PROCEDURE',
+      'REPLACE_PROCEDURE',
+      'RECREATE_PROCEDURE',
+      'CREATE_VIEW',
+      'REPLACE_VIEW',
+      'RECREATE_VIEW',
+      'CREATE_MATERIALIZED_VIEW',
+      'REPLACE_MATERIALIZED_VIEW',
+      'RECREATE_MATERIALIZED_VIEW',
+      'CREATE_TRIGGER',
+      'RECREATE_TRIGGER',
+      'ALTER_TRIGGER_ENABLE',
+      'REPLACE_TRIGGER',
+      'CREATE_POLICY',
+      'REPLACE_POLICY',
+      'RECREATE_POLICY',
+      'CREATE_RULE',
+      'REPLACE_RULE',
+      'RECREATE_RULE',
+      'CREATE_EVENT_TRIGGER',
+      'RECREATE_EVENT_TRIGGER',
+    ];
+
+    return changes
+      .filter(c => c.track === 2 || this.isBehavioral(c))
+      .sort((a, b) => {
+        const aIdx = order.indexOf(a.changeType);
+        const bIdx = order.indexOf(b.changeType);
+        if (aIdx === -1 && bIdx === -1) return 0;
+        if (aIdx === -1) return 1;
+        if (bIdx === -1) return -1;
+        return aIdx - bIdx;
+      });
+  }
+
+  /**
+   * Check if object type is behavioral
+   */
+  isBehavioral(change) {
+    const behavioralTypes = [
+      'view', 'materializedView', 'function', 'procedure',
+      'trigger', 'eventTrigger', 'policy', 'rule', 'aggregate'
+    ];
+    return behavioralTypes.includes(change.objectType);
+  }
+
+  /**
+   * Generate SQL for a behavioral change
+   * @param {Object} change
+   * @returns {string}
+   */
+  generateSQL(change) {
+    const changeType = change.changeType;
+    const objectType = change.objectType;
+    const obj = change.after || {};
+
+    switch (true) {
+      case changeType?.startsWith('CREATE') && objectType === 'view':
+        return this.generateCreateView(change, obj);
+
+      case changeType?.includes('REPLACE') && objectType === 'view':
+        return `CREATE OR REPLACE VIEW ${change.objectKey} AS ${obj.definition || change.desiredValue};`;
+
+      case changeType?.startsWith('CREATE') && objectType === 'materializedView':
+        return this.generateCreateMatView(change, obj);
+
+      case changeType?.startsWith('CREATE') && (objectType === 'function' || objectType === 'procedure'):
+        return this.generateCreateFunction(change, obj);
+
+      case changeType?.includes('REPLACE') && (objectType === 'function' || objectType === 'procedure'):
+        return this.generateReplaceFunction(change, obj);
+
+      case changeType?.startsWith('CREATE') && objectType === 'trigger':
+        return this.generateCreateTrigger(change, obj);
+
+      case changeType?.includes('RECREATE') && objectType === 'trigger':
+        return this.generateRecreateTrigger(change, obj);
+
+      case changeType === 'ALTER_TRIGGER_ENABLE':
+        return this.generateAlterTriggerEnable(change, obj);
+
+      case changeType?.startsWith('CREATE') && objectType === 'policy':
+        return this.generateCreatePolicy(change, obj);
+
+      case changeType?.includes('ALTER') && objectType === 'policy':
+        return this.generateAlterPolicy(change, obj);
+
+      case changeType?.startsWith('CREATE') && objectType === 'rule':
+        return this.generateCreateRule(change, obj);
+
+      case changeType?.startsWith('CREATE') && objectType === 'eventTrigger':
+        return this.generateCreateEventTrigger(change, obj);
+
+      default:
+        return this.getBehavioralDefaultSQL(change);
+    }
+  }
+
+  generateCreateView(change, view) {
+    let sql = `CREATE VIEW ${change.objectKey}`;
+    if (view.columns && view.columns.length > 0) {
+      sql += ` (${view.columns.map(c => this.ident(c)).join(', ')})`;
+    }
+    sql += ` AS ${view.definition}`;
+    if (view.checkOption) {
+      sql += ` WITH ${view.checkOption} CHECK OPTION`;
+    }
+    return sql + ';';
+  }
+
+  generateCreateMatView(change, mv) {
+    let sql = `CREATE MATERIALIZED VIEW ${change.objectKey}`;
+    sql += ` AS ${mv.definition}`;
+    if (mv.isWithData === false) {
+      sql += ' WITH NO DATA';
+    }
+    return sql + ';';
+  }
+
+  generateCreateFunction(change, fn) {
+    const keyword = change.objectType === 'procedure' ? 'PROCEDURE' : 'FUNCTION';
+    const args = (fn.argumentTypes || []).join(', ');
+
+    let sql = `CREATE ${keyword} ${change.objectKey}(${args})`;
+
+    if (keyword === 'FUNCTION') {
+      sql += ` RETURNS ${fn.returnType || 'void'}`;
+    }
+
+    sql += ` LANGUAGE ${fn.language || 'plpgsql'}`;
+
+    if (fn.volatility && fn.volatility !== 'VOLATILE') {
+      sql += ` ${fn.volatility}`;
+    }
+    if (fn.securityType === 'DEFINER') {
+      sql += ' SECURITY DEFINER';
+    }
+    if (fn.isNullCall === false) {
+      sql += ' RETURNS NULL ON NULL INPUT';
+    }
+    if (fn.parallelSafety) {
+      sql += ` PARALLEL ${fn.parallelSafety}`;
+    }
+    if (fn.cost) {
+      sql += ` COST ${fn.cost}`;
+    }
+
+    sql += ` AS $$${fn.source || ''}$$;`;
+    return sql;
+  }
+
+  generateReplaceFunction(change, fn) {
+    const keyword = change.objectType === 'procedure' ? 'PROCEDURE' : 'FUNCTION';
+    const args = (fn.argumentTypes || change.before?.argumentTypes || []).join(', ');
+
+    let sql = `CREATE OR REPLACE ${keyword} ${change.objectKey}(${args})`;
+
+    if (keyword === 'FUNCTION') {
+      sql += ` RETURNS ${fn.returnType || change.before?.returnType || 'void'}`;
+    }
+
+    sql += ` LANGUAGE ${fn.language || 'plpgsql'}`;
+    sql += ` AS $$${fn.source || change.desiredValue || ''}$$;`;
+
+    return sql;
+  }
+
+  generateCreateTrigger(change, trig) {
+    let sql = `CREATE TRIGGER ${this.ident(trig.name)}`;
+    sql += ` ${trig.timing}`;
+    sql += ` ${(trig.events || ['INSERT']).join(' OR ')}`;
+    sql += ` ON ${trig.schema ? this.ident(trig.schema) + '.' : ''}${this.ident(trig.tableName)}`;
+
+    if (trig.isConstraint) {
+      sql += ' FOR EACH ROW';
+      if (trig.constraint) {
+        sql += ` FROM ${trig.constraint}`;
+      }
+      if (trig.isDeferrable) {
+        sql += ` DEFERRABLE INITIALLY ${trig.deferred ? 'DEFERRED' : 'IMMEDIATE'}`;
+      }
+    } else {
+      sql += ` FOR EACH ${trig.orientation || 'ROW'}`;
+    }
+
+    if (trig.whenCondition) {
+      sql += ` WHEN (${trig.whenCondition})`;
+    }
+
+    sql += ` EXECUTE FUNCTION ${trig.functionName}`;
+    if (trig.functionArguments) {
+      sql += `(${trig.functionArguments})`;
+    }
+
+    return sql + ';';
+  }
+
+  generateRecreateTrigger(change, trig) {
+    const lines = [];
+    const trigName = trig.name || change.name;
+    const tableName = trig.tableName || change.after?.tableName;
+
+    lines.push(`DROP TRIGGER IF EXISTS ${this.ident(trigName)} ON ${this.ident(tableName)};`);
+    lines.push(this.generateCreateTrigger({ ...change, changeType: 'CREATE_TRIGGER' }, trig));
+
+    return lines.join('\n');
+  }
+
+  generateAlterTriggerEnable(change, trig) {
+    const trigName = trig.name || change.name;
+    const tableName = trig.tableName || change.after?.tableName;
+    const action = change.desiredValue === 'DISABLED' || change.desiredValue === false
+      ? 'DISABLE'
+      : 'ENABLE';
+
+    return `ALTER TABLE ${this.ident(tableName)} ${action} TRIGGER ${this.ident(trigName)};`;
+  }
+
+  generateCreatePolicy(change, policy) {
+    let sql = `CREATE POLICY ${this.ident(policy.name)} ON ${change.objectKey.split('.').slice(0, -1).join('.')}`;
+
+    if (policy.isPermissive) {
+      sql += ' AS PERMISSIVE';
+    } else {
+      sql += ' AS RESTRICTIVE';
+    }
+
+    if (policy.command) {
+      sql += ` FOR ${policy.command}`;
+    }
+
+    if (policy.roles && policy.roles.length > 0) {
+      sql += ' TO ' + policy.roles.map(r => r === 'PUBLIC' ? 'PUBLIC' : this.ident(r)).join(', ');
+    } else {
+      sql += ' TO PUBLIC';
+    }
+
+    if (policy.using) {
+      sql += ` USING (${policy.using})`;
+    }
+    if (policy.withCheck) {
+      sql += ` WITH CHECK (${policy.withCheck})`;
+    }
+
+    return sql + ';';
+  }
+
+  generateAlterPolicy(change, policy) {
+    const parts = change.objectKey.split('.');
+    const policyName = parts.pop();
+    const tableName = parts.join('.');
+    const lines = [];
+
+    if (change.property === 'roles' && change.desiredValue) {
+      const roles = change.desiredValue.map(r => r === 'PUBLIC' ? 'PUBLIC' : this.ident(r)).join(', ');
+      lines.push(`ALTER POLICY ${this.ident(policyName)} ON ${tableName} TO ${roles};`);
+    }
+    if (change.property === 'using' && change.desiredValue !== undefined) {
+      lines.push(`ALTER POLICY ${this.ident(policyName)} ON ${tableName} USING (${change.desiredValue || 'true'});`);
+    }
+    if (change.property === 'withCheck' && change.desiredValue) {
+      lines.push(`ALTER POLICY ${this.ident(policyName)} ON ${tableName} WITH CHECK (${change.desiredValue});`);
+    }
+
+    return lines.length > 0 ? lines.join('\n') : `-- No ALTER_POLICY SQL for ${change.objectKey}`;
+  }
+
+  generateCreateRule(change, rule) {
+    let sql = `CREATE RULE ${this.ident(rule.name)} AS`;
+    sql += rule.isInstead ? ' ON INSTEAD' : ' ON';
+    sql += ` ${rule.events?.join(' OR ') || 'INSERT'}`;
+    sql += ` TO ${change.objectKey.split('.').slice(0, -1).join('.')}`;
+
+    if (rule.condition) {
+      sql += ` WHERE (${rule.condition})`;
+    }
+
+    if (rule.commands && rule.commands.length > 0) {
+      sql += ' DO ';
+      if (rule.commands.length > 1) {
+        sql += `(${rule.commands.map(c => c.endsWith(';') ? c : c + ';').join(' ')})`;
+      } else {
+        sql += rule.commands[0];
+      }
+    } else {
+      sql += ' DO INSTEAD NOTHING';
+    }
+
+    return sql + ';';
+  }
+
+  generateCreateEventTrigger(change, et) {
+    let sql = `CREATE EVENT TRIGGER ${this.ident(et.name)}`;
+    sql += ` ON ${et.event}`;
+
+    if (et.tags && et.tags.length > 0) {
+      sql += ` WHEN TAG IN (${et.tags.map(t => `'${t}'`).join(', ')})`;
+    }
+
+    sql += ` EXECUTE FUNCTION ${et.functionName}`;
+    if (et.functionArguments) {
+      sql += `(${et.functionArguments})`;
+    }
+
+    return sql + ';';
+  }
+
+  getBehavioralDefaultSQL(change) {
+    if (change.changeType === 'DROP' || change.changeType?.startsWith('REMOVE')) {
+      return this.generateDrop(change);
+    }
+    return `-- Unsupported behavioral change: ${change.changeType} ${change.objectType}`;
+  }
+
+  generateDrop(change) {
+    const type = change.objectType;
+    const path = change.objectKey;
+
+    switch (type) {
+      case 'view':
+        return `DROP VIEW IF EXISTS ${path} CASCADE;`;
+      case 'materializedView':
+        return `DROP MATERIALIZED VIEW IF EXISTS ${path} CASCADE;`;
+      case 'function':
+        const fnArgs = change.before?.argumentTypes ? `(${change.before.argumentTypes.join(', ')})` : '';
+        return `DROP FUNCTION IF EXISTS ${path}${fnArgs} CASCADE;`;
+      case 'procedure':
+        const procArgs = change.before?.argumentTypes ? `(${change.before.argumentTypes.join(', ')})` : '';
+        return `DROP PROCEDURE IF EXISTS ${path}${procArgs} CASCADE;`;
+      case 'trigger':
+        const tableName = change.before?.tableName;
+        return `DROP TRIGGER IF EXISTS ${this.ident(change.name)} ON ${tableName};`;
+      case 'policy':
+        const polTable = change.before?.table;
+        return `DROP POLICY IF EXISTS ${this.ident(change.name)} ON ${polTable};`;
+      case 'rule':
+        const ruleTable = change.before?.tableName;
+        return `DROP RULE IF EXISTS ${this.ident(change.name)} ON ${ruleTable};`;
+      case 'eventTrigger':
+        return `DROP EVENT TRIGGER IF EXISTS ${this.ident(change.name)};`;
+      default:
+        return `-- Unsupported DROP for ${type}`;
+    }
+  }
+
+  ident(name) {
+    if (!name) return "''";
+    if (typeof name !== 'string') name = String(name);
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+}

package/src/behavioral/behavioral-extractor.js

@@ -0,0 +1,266 @@
+/**
+ * Behavioral Extractor - Extract behavioral objects from SchemaSnapshot
+ * Behavioral objects: views, functions, triggers, policies, rules, event triggers
+ */
+
+export class BehavioralExtractor {
+  /**
+   * Extract behavioral objects from a SchemaSnapshot
+   * @param {Object} snapshot - SchemaSnapshot from introspector
+   * @returns {Object} Extracted behavioral objects
+   */
+  extractFromSnapshot(snapshot) {
+    const behavioral = {
+      views: [],
+      materializedViews: [],
+      functions: [],
+      procedures: [],
+      triggers: [],
+      policies: [],
+      rules: [],
+      eventTriggers: [],
+    };
+
+    if (!snapshot || typeof snapshot !== 'object') {
+      return behavioral;
+    }
+
+    for (const [schemaName, schema] of Object.entries(snapshot.schemas || {})) {
+      this.extractViews(schema, schemaName, behavioral);
+      this.extractFunctions(schema, schemaName, behavioral);
+      this.extractTriggers(schema, schemaName, behavioral);
+      this.extractPolicies(schema, schemaName, behavioral);
+      this.extractRules(schema, schemaName, behavioral);
+    }
+
+    for (const [name, et] of Object.entries(snapshot.eventTriggers || {})) {
+      behavioral.eventTriggers.push({
+        name: et.name || name,
+        event: et.event,
+        functionName: et.functionName,
+        enabled: et.enabled,
+        tags: et.tags,
+        functionDependency: et.functionName,
+      });
+    }
+
+    return behavioral;
+  }
+
+  extractViews(schema, schemaName, behavioral) {
+    for (const view of schema.views || []) {
+      const viewObj = {
+        schema: schemaName,
+        name: view.name,
+        definition: view.definition,
+        checkOption: view.checkOption,
+        securityBarrier: view.securityBarrier,
+        securityInvoker: view.securityInvoker,
+        owner: view.owner,
+        dependencies: this.extractDependenciesFromSQL(view.definition, schemaName),
+      };
+      behavioral.views.push(viewObj);
+    }
+
+    for (const mv of schema.materializedViews || []) {
+      behavioral.materializedViews.push({
+        schema: schemaName,
+        name: mv.name,
+        definition: mv.definition,
+        isWithData: mv.isWithData,
+        tablespace: mv.tablespace,
+        dependencies: this.extractDependenciesFromSQL(mv.definition, schemaName),
+      });
+    }
+  }
+
+  extractFunctions(schema, schemaName, behavioral) {
+    for (const fn of schema.functions || []) {
+      behavioral.functions.push({
+        schema: schemaName,
+        name: fn.name,
+        argumentTypes: fn.argumentTypes || [],
+        returnType: fn.returnType,
+        source: fn.source,
+        language: fn.language,
+        volatility: fn.volatility,
+        isNullCall: fn.isNullCall,
+        securityType: fn.securityType,
+        parallelSafety: fn.parallelSafety,
+        cost: fn.cost,
+        rows: fn.rows,
+        owner: fn.owner,
+        typeDependencies: this.extractTypeDependencies(fn),
+      });
+    }
+
+    for (const proc of schema.procedures || []) {
+      behavioral.procedures.push({
+        schema: schemaName,
+        name: proc.name,
+        argumentTypes: proc.argumentTypes || [],
+        source: proc.source,
+        language: proc.language,
+        owner: proc.owner,
+        typeDependencies: this.extractTypeDependencies(proc),
+        isProcedure: true,
+      });
+    }
+  }
+
+  extractTriggers(schema, schemaName, behavioral) {
+    for (const trigger of schema.triggers || []) {
+      behavioral.triggers.push({
+        schema: schemaName,
+        name: trigger.name,
+        tableName: trigger.tableName,
+        timing: trigger.timing,
+        events: trigger.events,
+        functionName: trigger.functionName,
+        functionArguments: trigger.functionArguments,
+        whenCondition: trigger.whenCondition,
+        orientation: trigger.orientation,
+        enabled: trigger.enabled,
+        isConstraint: trigger.isConstraint,
+        functionDependency: trigger.functionName,
+      });
+    }
+  }
+
+  extractPolicies(schema, schemaName, behavioral) {
+    for (const policy of schema.policies || []) {
+      behavioral.policies.push({
+        schema: schemaName,
+        name: policy.name,
+        tableName: policy.tableName,
+        command: policy.command,
+        roles: policy.roles,
+        using: policy.using,
+        withCheck: policy.withCheck,
+        isPermissive: policy.isPermissive,
+        functionDependencies: [
+          ...this.extractFunctionRefs(policy.using),
+          ...this.extractFunctionRefs(policy.withCheck),
+        ],
+      });
+    }
+  }
+
+  extractRules(schema, schemaName, behavioral) {
+    for (const rule of schema.rules || []) {
+      behavioral.rules.push({
+        schema: schemaName,
+        name: rule.name,
+        tableName: rule.tableName,
+        events: rule.events,
+        isInstead: rule.isInstead,
+        commands: rule.commands,
+        condition: rule.condition,
+      });
+    }
+  }
+
+  /**
+   * Extract table/view/function dependencies from SQL
+   */
+  extractDependenciesFromSQL(sql, currentSchema) {
+    if (!sql) return [];
+
+    const deps = [];
+    const normalizedSQL = sql.toLowerCase();
+
+    const fromPattern = /(?:from|join)\s+(?:(\w+)\.)?(\w+)/gi;
+    let match;
+    while ((match = fromPattern.exec(normalizedSQL)) !== null) {
+      const schema = match[1] || currentSchema;
+      const name = match[2];
+      const keywords = ['select', 'where', 'and', 'or', 'on', 'as', 'set', 'into', 'values', 'table', 'only', 'update', 'delete', 'insert'];
+      if (!keywords.includes(name)) {
+        deps.push({ schema, name, type: 'table_or_view' });
+      }
+    }
+
+    return deps;
+  }
+
+  /**
+   * Extract function references from an expression
+   */
+  extractFunctionRefs(expression) {
+    if (!expression) return [];
+
+    const refs = [];
+    const fnPattern = /(\w+)\s*\(/gi;
+    let match;
+    while ((match = fnPattern.exec(expression)) !== null) {
+      const fnName = match[1].toLowerCase();
+      const keywords = ['coalesce', 'nullif', 'case', 'cast', 'exists', 'not', 'and', 'or', 'in', 'any', 'all', 'some', 'count', 'sum', 'avg', 'min', 'max', 'array', 'row', 'current_setting', 'concat', 'replace', 'substring'];
+      if (!keywords.includes(fnName)) {
+        refs.push(fnName);
+      }
+    }
+    return refs;
+  }
+
+  /**
+   * Extract type dependencies from a function
+   */
+  extractTypeDependencies(fn) {
+    const deps = [];
+
+    for (const argType of fn.argumentTypes || []) {
+      if (!this.isBuiltInType(argType)) {
+        deps.push(argType);
+      }
+    }
+
+    if (fn.returnType && !this.isBuiltInType(fn.returnType)) {
+      deps.push(fn.returnType);
+    }
+
+    return deps;
+  }
+
+  /**
+   * Check if a type is built-in
+   */
+  isBuiltInType(typeName) {
+    if (!typeName) return true;
+    const builtins = [
+      'integer', 'bigint', 'smallint', 'int', 'int2', 'int4', 'int8',
+      'serial', 'bigserial', 'smallserial', 'serial2', 'serial4', 'serial8',
+      'real', 'double precision', 'float', 'float4', 'float8', 'numeric', 'decimal', 'money',
+      'character varying', 'varchar', 'character', 'char', 'text',
+      'boolean', 'bool',
+      'date', 'time', 'timestamp', 'timestamptz', 'timetz', 'interval',
+      'uuid', 'json', 'jsonb', 'xml',
+      'bytea', 'bit', 'bit varying', 'varbit',
+      'point', 'line', 'lseg', 'box', 'path', 'polygon', 'circle',
+      'inet', 'cidr', 'macaddr', 'macaddr8',
+      'tsvector', 'tsquery',
+      'oid', 'regclass', 'regtype', 'regproc', 'regprocedure', 'regoper',
+      'record', 'void', 'trigger', 'event_trigger',
+      'any', 'anyelement', 'anyarray', 'anynonarray', 'anyenum', 'anyrange', 'anymultirange',
+    ];
+    const normalized = typeName.toLowerCase().replace(/\[\]$/, '').replace(/\s+/g, ' ');
+    return builtins.includes(normalized) || normalized.startsWith('"pg_');
+  }
+
+  /**
+   * Get execution order for behavioral objects
+   */
+  getExecutionOrder(behavioral) {
+    const order = [];
+
+    order.push(...(behavioral.functions || []).filter(f => !f.isProcedure));
+    order.push(...(behavioral.procedures || []));
+    order.push(...(behavioral.views || []));
+    order.push(...(behavioral.materializedViews || []));
+    order.push(...(behavioral.triggers || []));
+    order.push(...(behavioral.policies || []));
+    order.push(...(behavioral.rules || []));
+    order.push(...(behavioral.eventTriggers || []));
+
+    return order;
+  }
+}

package/src/behavioral/behavioral-puller.js

@@ -0,0 +1,35 @@
+export class BehavioralPuller {
+  /** @param {import('pg').Pool} pool */
+  constructor(pool) {
+    this.pool = pool;
+  }
+
+  /** @returns {Promise<Array<{type:string,phase:number,sql:string,name:string}>>} */
+  async pullFromDatabase() {
+    const items = [];
+
+    const extResult = await this.pool.query(`
+      SELECT 'CREATE EXTENSION IF NOT EXISTS ' || extname || ' SCHEMA ' || nspname AS sql,
+             extname AS name
+      FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace
+    `);
+    for (const row of extResult.rows) {
+      items.push({ type: 'EXTENSION', phase: 0, sql: row.sql, name: row.name });
+    }
+
+    const fnResult = await this.pool.query(`
+      SELECT 'CREATE OR REPLACE FUNCTION ' || n.nspname || '.' || p.proname || '(' || 
+             pg_get_function_identity_arguments(p.oid) || ') RETURNS ' || 
+             pg_get_function_result(p.oid) || ' LANGUAGE ' || l.lanname || ' AS $$' || 
+             p.prosrc || '$$;' AS sql,
+             n.nspname || '.' || p.proname AS name
+      FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace JOIN pg_language l ON l.oid = p.prolang
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    `);
+    for (const row of fnResult.rows) {
+      items.push({ type: 'FUNCTION', phase: 2, sql: row.sql, name: row.name });
+    }
+
+    return items;
+  }
+}

package/src/behavioral/index.js

@@ -0,0 +1,4 @@
+export { BehavioralExtractor } from './behavioral-extractor.js';
+export { BehavioralApplier } from './behavioral-applier.js';
+export { BehavioralPuller } from './behavioral-puller.js';
+export { PhaseSorter } from './phase-sorter.js';

package/src/behavioral/phase-sorter.js

@@ -0,0 +1,24 @@
+export class PhaseSorter {
+  /**
+   * @param {Array<{type:string,phase:number,sql:string,name:string}>} items
+   * @returns {Array<{type:string,phase:number,sql:string,name:string}>}
+   */
+  sort(items) {
+    return [...items].sort((a, b) => {
+      if (a.phase !== b.phase) return a.phase - b.phase;
+      
+      const phaseOrder = {
+        'EXTENSION': 1,
+        'TYPE': 2,
+        'TABLE': 3,
+        'FUNCTION': 4,
+        'VIEW': 5,
+        'TRIGGER': 6,
+        'POLICY': 7,
+        'GRANT': 8,
+      };
+      
+      return (phaseOrder[a.type] || 9) - (phaseOrder[b.type] || 9);
+    });
+  }
+}