@smartive/graphql-magic 23.3.0 → 23.4.0-next.5

package/src/migrations/parse-functions.ts

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync } from 'fs';
+
+export type ParsedFunction = {
+  name: string;
+  signature: string;
+  body: string;
+  fullDefinition: string;
+  isAggregate: boolean;
+};
+
+const normalizeFunctionBody = (body: string): string => {
+  return body
+    .replace(/\s+/g, ' ')
+    .replace(/\s*\(\s*/g, '(')
+    .replace(/\s*\)\s*/g, ')')
+    .replace(/\s*,\s*/g, ',')
+    .trim();
+};
+
+const normalizeAggregateDefinition = (definition: string): string => {
+  let normalized = definition
+    .replace(/\s+/g, ' ')
+    .replace(/\s*\(\s*/g, '(')
+    .replace(/\s*\)\s*/g, ')')
+    .replace(/\s*,\s*/g, ',')
+    .trim();
+
+  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(',')
+    .map((arg) => {
+      const trimmed = arg.trim();
+      const typeMatch = trimmed.match(/(\w+)\s+(\w+(?:\s*\[\])?)/);
+      if (typeMatch) {
+        return `${typeMatch[1]} ${typeMatch[2]}`;
+      }
+
+      return trimmed;
+    })
+    .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 content = readFileSync(filePath, 'utf-8');
+  const functions: ParsedFunction[] = [];
+
+  const functionRegex =
+    /CREATE\s+(OR\s+REPLACE\s+)?(FUNCTION|AGGREGATE)\s+[\s\S]*?(?=CREATE\s+(OR\s+REPLACE\s+)?(FUNCTION|AGGREGATE)|$)/gi;
+  let match;
+  let lastIndex = 0;
+
+  while ((match = functionRegex.exec(content)) !== null) {
+    if (match.index < lastIndex) {
+      continue;
+    }
+    lastIndex = match.index + match[0].length;
+
+    const definition = match[0].trim();
+    const isAggregate = /CREATE\s+(OR\s+REPLACE\s+)?AGGREGATE/i.test(definition);
+    const signature = extractFunctionSignature(definition, isAggregate);
+
+    if (!signature) {
+      continue;
+    }
+
+    const nameMatch = signature.match(/^([^(]+)\(/);
+    const name = nameMatch ? nameMatch[1].trim().split('.').pop() || '' : '';
+    const body = isAggregate ? definition : extractFunctionBody(definition);
+
+    functions.push({
+      name,
+      signature,
+      body: isAggregate ? normalizeAggregateDefinition(body) : normalizeFunctionBody(body),
+      fullDefinition: definition,
+      isAggregate,
+    });
+  }
+
+  return functions;
+};

package/src/migrations/update-functions.ts

@@ -0,0 +1,216 @@
+import { Knex } from 'knex';
+import { ParsedFunction, parseFunctionsFile } from './parse-functions';
+
+type DatabaseFunction = {
+  name: string;
+  signature: string;
+  body: string;
+  isAggregate: boolean;
+  definition?: string;
+};
+
+const normalizeFunctionBody = (body: string): string => {
+  return body
+    .replace(/\s+/g, ' ')
+    .replace(/\s*\(\s*/g, '(')
+    .replace(/\s*\)\s*/g, ')')
+    .replace(/\s*,\s*/g, ',')
+    .trim();
+};
+
+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, functionsFilePath: string): Promise<void> => {
+  const definedFunctions = parseFunctionsFile(functionsFilePath);
+
+  if (definedFunctions.length === 0) {
+    return;
+  }
+
+  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.');
+  }
+};

package/src/models/model-definitions.ts

@@ -90,7 +90,10 @@ export type EntityFieldDefinition = FieldDefinitionBase &
     indent?: boolean;
     // If true the field is hidden in the admin interface
     hidden?: boolean;
-    generateAs?: string;
+    generateAs?: {
+      expression: string;
+      type: 'virtual' | 'stored' | 'expression';
+    };
 
     // Temporary fields for the generation of migrations
     deleted?: true;

package/src/resolvers/filters.ts

@@ -3,7 +3,7 @@ import { EntityModel, FullContext, getPermissionStack } from '..';
 import { ForbiddenError, UserInputError } from '../errors';
 import { OrderBy, Where, normalizeArguments } from './arguments';
 import { FieldResolverNode } from './node';
-import { Joins, QueryBuilderOps, addJoin, apply, applyJoins, getColumn, ors } from './utils';
+import { Joins, QueryBuilderOps, addJoin, apply, applyJoins, getColumn, getColumnExpression, ors } from './utils';
 
 export const SPECIAL_FILTERS: Record<string, string> = {
   GT: '?? > ?',
@@ -157,19 +157,32 @@ const applyWhere = (node: FilterNode, where: Where | undefined, ops: QueryBuilde
         // Should not happen
         throw new Error(`Invalid filter ${key}.`);
       }
-      ops.push((query) => query.whereRaw(SPECIAL_FILTERS[filter], [getColumn(node, actualKey), value as string]));
+      const actualField = node.model.getField(actualKey);
+      const isExpressionField = actualField.generateAs?.type === 'expression';
+      const actualColumn = isExpressionField ? getColumnExpression(node, actualKey) : getColumn(node, actualKey);
+      if (isExpressionField) {
+        const operator = filter === 'GT' ? '>' : filter === 'GTE' ? '>=' : filter === 'LT' ? '<' : '<=';
+        ops.push((query) => query.whereRaw(`${actualColumn} ${operator} ?`, [value as string]));
+      } else {
+        ops.push((query) => query.whereRaw(SPECIAL_FILTERS[filter], [actualColumn, value as string]));
+      }
       continue;
     }
 
     const field = node.model.getField(key);
 
-    const column = getColumn(node, key);
+    const isExpressionField = field.generateAs?.type === 'expression';
+    const column = isExpressionField ? getColumnExpression(node, key) : getColumn(node, key);
 
     if (field.kind === 'relation') {
       const relation = node.model.getRelation(field.name);
 
       if (value === null) {
-        ops.push((query) => query.whereNull(column));
+        if (isExpressionField) {
+          ops.push((query) => query.whereRaw(`${column} IS NULL`));
+        } else {
+          ops.push((query) => query.whereNull(column));
+        }
         continue;
       }
 
@@ -189,35 +202,65 @@ const applyWhere = (node: FilterNode, where: Where | undefined, ops: QueryBuilde
 
     if (Array.isArray(value)) {
       if (field && field.list) {
-        ops.push((query) =>
-          ors(
-            query,
-            value.map((v) => (subQuery) => subQuery.whereRaw('? = ANY(??)', [v, column] as string[])),
-          ),
-        );
+        if (isExpressionField) {
+          ops.push((query) =>
+            ors(
+              query,
+              value.map((v) => (subQuery) => subQuery.whereRaw(`? = ANY(${column})`, [v])),
+            ),
+          );
+        } else {
+          ops.push((query) =>
+            ors(
+              query,
+              value.map((v) => (subQuery) => subQuery.whereRaw('? = ANY(??)', [v, column] as string[])),
+            ),
+          );
+        }
         continue;
       }
 
       if (value.some((v) => v === null)) {
         if (value.some((v) => v !== null)) {
-          ops.push((query) =>
-            ors(query, [
-              (subQuery) => subQuery.whereIn(column, value.filter((v) => v !== null) as string[]),
-              (subQuery) => subQuery.whereNull(column),
-            ]),
-          );
+          if (isExpressionField) {
+            ops.push((query) =>
+              ors(query, [
+                (subQuery) => subQuery.whereRaw(`${column} IN (?)`, [value.filter((v) => v !== null) as string[]]),
+                (subQuery) => subQuery.whereRaw(`${column} IS NULL`),
+              ]),
+            );
+          } else {
+            ops.push((query) =>
+              ors(query, [
+                (subQuery) => subQuery.whereIn(column, value.filter((v) => v !== null) as string[]),
+                (subQuery) => subQuery.whereNull(column),
+              ]),
+            );
+          }
           continue;
         }
 
-        ops.push((query) => query.whereNull(column));
+        if (isExpressionField) {
+          ops.push((query) => query.whereRaw(`${column} IS NULL`));
+        } else {
+          ops.push((query) => query.whereNull(column));
+        }
         continue;
       }
 
-      ops.push((query) => query.whereIn(column, value as string[]));
+      if (isExpressionField) {
+        ops.push((query) => query.whereRaw(`${column} IN (?)`, [value as string[]]));
+      } else {
+        ops.push((query) => query.whereIn(column, value as string[]));
+      }
       continue;
     }
 
-    ops.push((query) => query.where({ [column]: value }));
+    if (isExpressionField) {
+      ops.push((query) => query.whereRaw(`${column} = ?`, [value]));
+    } else {
+      ops.push((query) => query.where({ [column]: value }));
+    }
   }
 };
 
@@ -226,11 +269,18 @@ const applySearch = (node: FieldResolverNode, search: string, query: Knex.QueryB
     query,
     node.model.fields
       .filter(({ searchable }) => searchable)
-      .map(
-        ({ name }) =>
-          (query) =>
-            query.whereRaw('??::text ILIKE ?', [getColumn(node, name), `%${search}%`]),
-      ),
+      .map((field) => {
+        const isExpressionField = field.generateAs?.type === 'expression';
+        const column = isExpressionField ? getColumnExpression(node, field.name) : getColumn(node, field.name);
+
+        return (query: Knex.QueryBuilder) => {
+          if (isExpressionField) {
+            return query.whereRaw(`${column}::text ILIKE ?`, [`%${search}%`]);
+          }
+
+          return query.whereRaw('??::text ILIKE ?', [column, `%${search}%`]);
+        };
+      }),
   );
 
 const applyOrderBy = (node: FilterNode, orderBy: OrderBy | OrderBy[], query: Knex.QueryBuilder, joins: Joins) => {
@@ -261,6 +311,12 @@ const applyOrderBy = (node: FilterNode, orderBy: OrderBy | OrderBy[], query: Kne
     }
 
     // Simple field
-    void query.orderBy(getColumn(node, key), value as 'ASC' | 'DESC');
+    const isExpressionField = field.generateAs?.type === 'expression';
+    const column = isExpressionField ? getColumnExpression(node, key) : getColumn(node, key);
+    if (isExpressionField) {
+      void query.orderByRaw(`${column} ${value}`);
+    } else {
+      void query.orderBy(column, value as 'ASC' | 'DESC');
+    }
   }
 };

package/src/resolvers/selects.ts

@@ -13,6 +13,7 @@ import {
   isFieldNode,
 } from '.';
 import { PermissionError, UserInputError, getRole } from '..';
+import { getColumnName } from './utils';
 
 export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
   if (node.isAggregate) {
@@ -32,7 +33,15 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
     ...[
       { tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: 'id', fieldAlias: ID_ALIAS },
       ...(node.model.root
-        ? [{ tableAlias: node.rootTableAlias, resultAlias: node.resultAlias, field: 'type', fieldAlias: TYPE_ALIAS }]
+        ? [
+            {
+              tableAlias: node.rootTableAlias,
+              resultAlias: node.resultAlias,
+              field: 'type',
+              fieldAlias: TYPE_ALIAS,
+              generateAs: undefined,
+            },
+          ]
         : []),
       ...getSimpleFields(node)
         .filter((fieldNode) => {
@@ -69,12 +78,36 @@ export const applySelects = (node: ResolverNode, query: Knex.QueryBuilder, joins
             tableAlias: field.inherited ? node.rootTableAlias : node.tableAlias,
             resultAlias: node.resultAlias,
             fieldAlias,
+            generateAs: field.generateAs,
           };
         }),
-    ].map(
-      ({ tableAlias, resultAlias, field, fieldAlias }) =>
-        `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`,
-    ),
+    ].map(({ tableAlias, resultAlias, field, fieldAlias, generateAs }) => {
+      if (generateAs?.type === 'expression') {
+        const tableShortAlias = node.ctx.aliases.getShort(tableAlias);
+        const resultShortAlias = node.ctx.aliases.getShort(resultAlias);
+        const expression = generateAs.expression.replace(/\b(\w+)\b/g, (match, columnName) => {
+          const field = node.model.fields.find((f) => {
+            if (f.name === columnName) {
+              return true;
+            }
+            const actualColumnName = getColumnName(f);
+
+            return actualColumnName === columnName;
+          });
+          if (field) {
+            const actualColumnName = getColumnName(field);
+
+            return `${tableShortAlias}.${actualColumnName}`;
+          }
+
+          return match;
+        });
+
+        return node.ctx.knex.raw(`(${expression}) as ??`, [`${resultShortAlias}__${fieldAlias}`]);
+      }
+
+      return `${node.ctx.aliases.getShort(tableAlias)}.${field} as ${node.ctx.aliases.getShort(resultAlias)}__${fieldAlias}`;
+    }),
   );
 
   for (const subNode of getInlineFragments(node)) {

package/src/resolvers/utils.ts

@@ -218,6 +218,38 @@ export const getColumn = (
   return `${node.ctx.aliases.getShort(field.inherited ? node.rootTableAlias : node.tableAlias)}.${getColumnName(field)}`;
 };
 
+export const getColumnExpression = (
+  node: Pick<ResolverNode, 'model' | 'ctx' | 'rootTableAlias' | 'tableAlias'>,
+  fieldName: string,
+) => {
+  const field = node.model.fields.find((field) => field.name === fieldName)!;
+
+  if (field.generateAs?.type === 'expression') {
+    const expression = field.generateAs.expression.replace(/\b(\w+)\b/g, (match, columnName) => {
+      const referencedField = node.model.fields.find((f) => {
+        if (f.name === columnName) {
+          return true;
+        }
+        const actualColumnName = getColumnName(f);
+
+        return actualColumnName === columnName;
+      });
+      if (referencedField) {
+        const actualColumnName = getColumnName(referencedField);
+        const referencedTableAlias = referencedField.inherited ? node.rootTableAlias : node.tableAlias;
+
+        return `${node.ctx.aliases.getShort(referencedTableAlias)}.${actualColumnName}`;
+      }
+
+      return match;
+    });
+
+    return `(${expression})`;
+  }
+
+  return getColumn(node, fieldName);
+};
+
 export const getTechnicalDisplay = (model: EntityModel, entity: Entity) =>
   model.displayField && entity[model.displayField]
     ? `${model.name} "${entity[model.displayField]}" (${entity.id})`