@smartive/graphql-magic 23.4.0-next.8 → 23.4.1

package/src/bin/gqm/parse-functions.ts

@@ -1,141 +0,0 @@
-import { existsSync } from 'fs';
-import { IndentationText, Project } from 'ts-morph';
-import { ParsedFunction } from '../../migrations/types';
-import { staticEval } from './static-eval';
-import { findDeclarationInFile } from './utils';
-
-const normalizeWhitespace = (str: string): string => {
-  return str
-    .replace(/\s+/g, ' ')
-    .replace(/\s*\(\s*/g, '(')
-    .replace(/\s*\)\s*/g, ')')
-    .replace(/\s*,\s*/g, ',')
-    .replace(/\s*;\s*/g, ';')
-    .trim();
-};
-
-const normalizeFunctionBody = (body: string): string => {
-  return normalizeWhitespace(body);
-};
-
-const normalizeAggregateDefinition = (definition: string): string => {
-  let normalized = normalizeWhitespace(definition);
-
-  const initCondMatch = normalized.match(/INITCOND\s*=\s*([^,)]+)/i);
-  if (initCondMatch) {
-    const initCondValue = initCondMatch[1].trim();
-    const unquoted = initCondValue.replace(/^['"]|['"]$/g, '');
-    if (/^\d+$/.test(unquoted)) {
-      normalized = normalized.replace(/INITCOND\s*=\s*[^,)]+/i, `INITCOND = '${unquoted}'`);
-    }
-  }
-
-  return normalized;
-};
-
-const extractFunctionSignature = (definition: string, isAggregate: boolean): string | null => {
-  if (isAggregate) {
-    const createMatch = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+([^(]+)\(/i);
-    if (!createMatch) {
-      return null;
-    }
-
-    const functionNamePart = createMatch[2].trim().replace(/^[^.]+\./, '');
-    const argsMatch = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+[^(]+\(([^)]*)\)/i);
-    const args = argsMatch ? argsMatch[2].trim() : '';
-
-    return `${functionNamePart}(${args})`;
-  }
-
-  const createMatch = definition.match(/CREATE\s+(OR\s+REPLACE\s+)?FUNCTION\s+([^(]+)\(/i);
-  if (!createMatch) {
-    return null;
-  }
-
-  const functionNamePart = createMatch[2].trim().replace(/^[^.]+\./, '');
-  const fullArgsMatch = definition.match(
-    /CREATE\s+(OR\s+REPLACE\s+)?FUNCTION\s+[^(]+\(([\s\S]*?)\)\s*(RETURNS|LANGUAGE|AS|STRICT|IMMUTABLE|STABLE|VOLATILE|SECURITY)/i,
-  );
-
-  if (!fullArgsMatch) {
-    return null;
-  }
-
-  const argsSection = fullArgsMatch[2].trim();
-  const args = argsSection
-    .split(/\s*,\s*/)
-    .map((arg) => {
-      return arg.trim().replace(/\s+/g, ' ');
-    })
-    .join(', ');
-
-  return `${functionNamePart}(${args})`;
-};
-
-const extractFunctionBody = (definition: string): string => {
-  const dollarQuoteMatch = definition.match(/AS\s+\$([^$]*)\$([\s\S]*?)\$\1\$/i);
-  if (dollarQuoteMatch) {
-    return dollarQuoteMatch[2].trim();
-  }
-
-  const bodyMatch = definition.match(/AS\s+\$\$([\s\S]*?)\$\$/i) || definition.match(/AS\s+['"]([\s\S]*?)['"]/i);
-  if (bodyMatch) {
-    return bodyMatch[1].trim();
-  }
-
-  return definition;
-};
-
-export const parseFunctionsFile = (filePath: string): ParsedFunction[] => {
-  if (!existsSync(filePath)) {
-    return [];
-  }
-
-  const project = new Project({
-    manipulationSettings: {
-      indentationText: IndentationText.TwoSpaces,
-    },
-  });
-  const sourceFile = project.addSourceFileAtPath(filePath);
-
-  try {
-    const functionsDeclaration = findDeclarationInFile(sourceFile, 'functions');
-    const functionsArray = staticEval(functionsDeclaration, {}) as string[];
-
-    if (!Array.isArray(functionsArray)) {
-      return [];
-    }
-
-    const parsedFunctions: ParsedFunction[] = [];
-
-    for (const definition of functionsArray) {
-      if (!definition || typeof definition !== 'string') {
-        continue;
-      }
-
-      const trimmedDefinition = definition.trim();
-      const isAggregate = /CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE/i.test(trimmedDefinition);
-      const signature = extractFunctionSignature(trimmedDefinition, isAggregate);
-
-      if (!signature) {
-        continue;
-      }
-
-      const nameMatch = signature.match(/^([^(]+)\(/);
-      const name = nameMatch ? nameMatch[1].trim().split('.').pop() || '' : '';
-      const body = isAggregate ? trimmedDefinition : extractFunctionBody(trimmedDefinition);
-
-      parsedFunctions.push({
-        name,
-        signature,
-        body: isAggregate ? normalizeAggregateDefinition(body) : normalizeFunctionBody(body),
-        fullDefinition: trimmedDefinition,
-        isAggregate,
-      });
-    }
-
-    return parsedFunctions;
-  } catch (error) {
-    return [];
-  }
-};

package/src/migrations/generate-functions.ts

@@ -1,74 +0,0 @@
-import { Knex } from 'knex';
-
-export const generateFunctionsFromDatabase = async (knex: Knex): Promise<string> => {
-  const regularFunctions = await knex.raw(`
-    SELECT 
-      pg_get_functiondef(p.oid) as definition
-    FROM pg_proc p
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-
-  const aggregateFunctions = await knex.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      a.aggtransfn::regproc::text as trans_func,
-      a.aggfinalfn::regproc::text as final_func,
-      a.agginitval as init_val,
-      pg_catalog.format_type(a.aggtranstype, NULL) as state_type
-    FROM pg_proc p
-    JOIN pg_aggregate a ON p.oid = a.aggfnoid
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-
-  const functions: string[] = [];
-
-  for (const row of regularFunctions.rows || []) {
-    if (row.definition) {
-      functions.push(row.definition.trim());
-    }
-  }
-
-  for (const row of aggregateFunctions.rows || []) {
-    const name = row.name || '';
-    const argumentsStr = row.arguments || '';
-    const transFunc = row.trans_func || '';
-    const finalFunc = row.final_func || '';
-    const initVal = row.init_val;
-    const stateType = row.state_type || '';
-
-    if (!name || !transFunc || !stateType) {
-      continue;
-    }
-
-    let aggregateDef = `CREATE AGGREGATE ${name}(${argumentsStr}) (\n`;
-    aggregateDef += `  SFUNC = ${transFunc},\n`;
-    aggregateDef += `  STYPE = ${stateType}`;
-
-    if (finalFunc) {
-      aggregateDef += `,\n  FINALFUNC = ${finalFunc}`;
-    }
-
-    if (initVal !== null && initVal !== undefined) {
-      const initValStr = typeof initVal === 'string' ? `'${initVal}'` : String(initVal);
-      aggregateDef += `,\n  INITCOND = ${initValStr}`;
-    }
-
-    aggregateDef += '\n);';
-
-    functions.push(aggregateDef);
-  }
-
-  if (functions.length === 0) {
-    return `export const functions: string[] = [];\n`;
-  }
-
-  const functionsArrayString = functions.map((func) => `  ${JSON.stringify(func)}`).join(',\n');
-
-  return `export const functions: string[] = [\n${functionsArrayString},\n];\n`;
-};

package/src/migrations/types.ts

@@ -1,7 +0,0 @@
-export type ParsedFunction = {
-  name: string;
-  signature: string;
-  body: string;
-  fullDefinition: string;
-  isAggregate: boolean;
-};

package/src/migrations/update-functions.ts

@@ -1,221 +0,0 @@
-import { Knex } from 'knex';
-import { ParsedFunction } from './types';
-
-type DatabaseFunction = {
-  name: string;
-  signature: string;
-  body: string;
-  isAggregate: boolean;
-  definition?: string;
-};
-
-const normalizeWhitespace = (str: string): string => {
-  return str
-    .replace(/\s+/g, ' ')
-    .replace(/\s*\(\s*/g, '(')
-    .replace(/\s*\)\s*/g, ')')
-    .replace(/\s*,\s*/g, ',')
-    .replace(/\s*;\s*/g, ';')
-    .trim();
-};
-
-const normalizeFunctionBody = (body: string): string => {
-  return normalizeWhitespace(body);
-};
-
-const extractFunctionBody = (definition: string): string => {
-  const dollarQuoteMatch = definition.match(/AS\s+\$([^$]*)\$([\s\S]*?)\$\1\$/i);
-  if (dollarQuoteMatch) {
-    return dollarQuoteMatch[2].trim();
-  }
-
-  const bodyMatch = definition.match(/AS\s+\$\$([\s\S]*?)\$\$/i) || definition.match(/AS\s+['"]([\s\S]*?)['"]/i);
-  if (bodyMatch) {
-    return bodyMatch[1].trim();
-  }
-
-  return definition;
-};
-
-const getDatabaseFunctions = async (knex: Knex): Promise<DatabaseFunction[]> => {
-  const regularFunctions = await knex.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      pg_get_functiondef(p.oid) as definition,
-      false as is_aggregate
-    FROM pg_proc p
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    AND NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid)
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-
-  const aggregateFunctions = await knex.raw(`
-    SELECT 
-      p.proname as name,
-      pg_get_function_identity_arguments(p.oid) as arguments,
-      a.aggtransfn::regproc::text as trans_func,
-      a.aggfinalfn::regproc::text as final_func,
-      a.agginitval as init_val,
-      pg_catalog.format_type(a.aggtranstype, NULL) as state_type,
-      true as is_aggregate
-    FROM pg_proc p
-    JOIN pg_aggregate a ON p.oid = a.aggfnoid
-    JOIN pg_namespace n ON p.pronamespace = n.oid
-    WHERE n.nspname = 'public'
-    ORDER BY p.proname, pg_get_function_identity_arguments(p.oid)
-  `);
-
-  const result: DatabaseFunction[] = [];
-
-  for (const row of regularFunctions.rows || []) {
-    const definition = row.definition || '';
-    const name = row.name || '';
-    const argumentsStr = row.arguments || '';
-
-    if (!definition) {
-      continue;
-    }
-
-    const signature = `${name}(${argumentsStr})`;
-    const body = normalizeFunctionBody(extractFunctionBody(definition));
-
-    result.push({
-      name,
-      signature,
-      body,
-      isAggregate: false,
-      definition,
-    });
-  }
-
-  for (const row of aggregateFunctions.rows || []) {
-    const name = row.name || '';
-    const argumentsStr = row.arguments || '';
-    const transFunc = row.trans_func || '';
-    const finalFunc = row.final_func || '';
-    const initVal = row.init_val;
-    const stateType = row.state_type || '';
-
-    const signature = `${name}(${argumentsStr})`;
-
-    let aggregateDef = `CREATE AGGREGATE ${name}(${argumentsStr}) (`;
-    aggregateDef += `SFUNC = ${transFunc}, STYPE = ${stateType}`;
-
-    if (finalFunc) {
-      aggregateDef += `, FINALFUNC = ${finalFunc}`;
-    }
-
-    if (initVal !== null && initVal !== undefined) {
-      const initValStr = typeof initVal === 'string' ? `'${initVal}'` : String(initVal);
-      aggregateDef += `, INITCOND = ${initValStr}`;
-    }
-
-    aggregateDef += ');';
-
-    result.push({
-      name,
-      signature,
-      body: normalizeFunctionBody(aggregateDef),
-      isAggregate: true,
-      definition: aggregateDef,
-    });
-  }
-
-  return result;
-};
-
-const compareFunctions = (defined: ParsedFunction, db: DatabaseFunction): { changed: boolean; diff?: string } => {
-  const definedBody = normalizeFunctionBody(defined.body);
-  const dbBody = normalizeFunctionBody(db.body);
-
-  if (definedBody !== dbBody) {
-    const definedPreview = definedBody.length > 200 ? `${definedBody.substring(0, 200)}...` : definedBody;
-    const dbPreview = dbBody.length > 200 ? `${dbBody.substring(0, 200)}...` : dbBody;
-
-    return {
-      changed: true,
-      diff: `Definition changed:\n  File: ${definedPreview}\n  DB:   ${dbPreview}`,
-    };
-  }
-
-  return { changed: false };
-};
-
-export const updateFunctions = async (knex: Knex, parsedFunctions: ParsedFunction[]): Promise<void> => {
-  if (parsedFunctions.length === 0) {
-    return;
-  }
-
-  const definedFunctions = parsedFunctions;
-
-  const dbFunctions = await getDatabaseFunctions(knex);
-  const dbFunctionsBySignature = new Map<string, DatabaseFunction>();
-  for (const func of dbFunctions) {
-    dbFunctionsBySignature.set(func.signature, func);
-  }
-
-  console.info(`Found ${definedFunctions.length} function(s) in file, ${dbFunctions.length} function(s) in database.`);
-
-  let updatedCount = 0;
-  let skippedCount = 0;
-
-  for (const definedFunc of definedFunctions) {
-    const dbFunc = dbFunctionsBySignature.get(definedFunc.signature);
-
-    if (!dbFunc) {
-      try {
-        await knex.raw(definedFunc.fullDefinition);
-        console.info(`✓ Created ${definedFunc.isAggregate ? 'aggregate' : 'function'}: ${definedFunc.signature}`);
-        updatedCount++;
-      } catch (error: any) {
-        console.error(
-          `✗ Failed to create ${definedFunc.isAggregate ? 'aggregate' : 'function'} ${definedFunc.signature}:`,
-          error.message,
-        );
-        throw error;
-      }
-    } else {
-      const comparison = compareFunctions(definedFunc, dbFunc);
-      if (comparison.changed) {
-        console.info(`\n⚠ ${definedFunc.isAggregate ? 'Aggregate' : 'Function'} ${definedFunc.signature} has changes:`);
-        if (comparison.diff) {
-          console.info(comparison.diff);
-        }
-        try {
-          if (definedFunc.isAggregate) {
-            const dropMatch = definedFunc.fullDefinition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+([^(]+)\(/i);
-            if (dropMatch) {
-              const functionName = dropMatch[2].trim();
-              const argsMatch = definedFunc.fullDefinition.match(/CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE\s+[^(]+\(([^)]*)\)/i);
-              const args = argsMatch ? argsMatch[2].trim() : '';
-              await knex.raw(`DROP AGGREGATE IF EXISTS ${functionName}${args ? `(${args})` : ''}`);
-            }
-          }
-          await knex.raw(definedFunc.fullDefinition);
-          console.info(`✓ Updated ${definedFunc.isAggregate ? 'aggregate' : 'function'}: ${definedFunc.signature}\n`);
-          updatedCount++;
-        } catch (error: any) {
-          console.error(
-            `✗ Failed to update ${definedFunc.isAggregate ? 'aggregate' : 'function'} ${definedFunc.signature}:`,
-            error.message,
-          );
-          throw error;
-        }
-      } else {
-        console.info(
-          `○ Skipped ${definedFunc.isAggregate ? 'aggregate' : 'function'} (unchanged): ${definedFunc.signature}`,
-        );
-        skippedCount++;
-      }
-    }
-  }
-
-  console.info(`\nSummary: ${updatedCount} updated, ${skippedCount} skipped`);
-  if (updatedCount > 0) {
-    console.info('Functions updated successfully.');
-  } else {
-    console.info('All functions are up to date.');
-  }
-};