@smartive/graphql-magic 23.2.0 → 23.4.0-next.4

package/src/bin/gqm/static-eval.ts

@@ -1,5 +1,6 @@
 import { camelCase, Dictionary, kebabCase, lowerFirst, snakeCase, startCase, upperFirst } from 'lodash';
 import {
+  BindingElement,
   CaseClause,
   ElementAccessExpression,
   Identifier,
@@ -47,6 +48,7 @@ export const staticEval = (node: Node | undefined, context: Dictionary<unknown>)
 
 const VISITOR: Visitor<unknown, Dictionary<unknown>> = {
   undefined: () => undefined,
+  [SyntaxKind.BindingElement]: (node: BindingElement, context) => context[node.getName()],
   [SyntaxKind.VariableDeclaration]: (node, context) => staticEval(node.getInitializer(), context),
   [SyntaxKind.ArrayLiteralExpression]: (node, context) => {
     const values: unknown[] = [];
@@ -146,7 +148,52 @@ const VISITOR: Visitor<unknown, Dictionary<unknown>> = {
       const parameters: Dictionary<unknown> = {};
       let i = 0;
       for (const parameter of node.getParameters()) {
-        parameters[parameter.getName()] = args[i];
+        const argument = args[i];
+
+        if (parameter.isRestParameter()) {
+          parameters[parameter.getName()] = args.slice(i);
+        } else {
+          const nameNode = parameter.getNameNode();
+          if (Node.isObjectBindingPattern(nameNode)) {
+            const value = (argument ?? {}) as Dictionary<unknown>;
+            const usedKeys = new Set<string>();
+
+            for (const element of nameNode.getElements()) {
+              if (element.getDotDotDotToken()) {
+                // Handle rest element (...args)
+                const restName = element.getName();
+                const restValue: Dictionary<unknown> = {};
+                for (const key in value) {
+                  if (!usedKeys.has(key)) {
+                    restValue[key] = value[key];
+                  }
+                }
+                parameters[restName] = restValue;
+              } else {
+                // Handle property destructuring (prop: alias = defaultValue)
+                const propertyNameNode = element.getPropertyNameNode();
+                const elementDetails = element.getNameNode();
+
+                // If "prop: alias", key is "prop". If just "alias", key is "alias".
+                const key = propertyNameNode ? propertyNameNode.getText() : elementDetails.getText();
+                const variableName = elementDetails.getText();
+
+                usedKeys.add(key);
+
+                let propertyValue = value[key];
+
+                // Handle default values (= defaultValue)
+                if (propertyValue === undefined && element.hasInitializer()) {
+                  propertyValue = staticEval(element.getInitializer(), { ...context, ...parameters });
+                }
+
+                parameters[variableName] = propertyValue;
+              }
+            }
+          } else {
+            parameters[parameter.getName()] = argument;
+          }
+        }
         i++;
       }
       return staticEval(node.getBody(), { ...context, ...parameters });

package/src/migrations/generate-functions.ts

@@ -0,0 +1,72 @@
+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 '-- PostgreSQL functions\n-- No functions found in database\n';
+  }
+
+  return functions.join('\n\n') + '\n';
+};