@smartive/graphql-magic 23.4.1 → 23.5.0-next.2

package/docs/docs/3-fields.md

@@ -341,3 +341,152 @@ the reverse relation will automatically be `Post.comments`. With `reverse` this
 ### `onDelete`
 
 Only available on relation fields. Can be `"cascade"` (default), `"restrict"` or `"set-null"`.
+
+### `generateAs`
+
+Only available on entity fields. Allows you to define fields that are computed from SQL expressions rather than stored directly. This option accepts an object with:
+
+- `expression`: A SQL expression string that defines how the field is computed
+- `type`: One of `'virtual'`, `'stored'`, or `'expression'`
+
+#### `type: 'virtual'` and `type: 'stored'`
+
+These types create SQL generated columns in the database. The difference is:
+
+- **`'virtual'`**: The value is computed on-the-fly when queried (not stored in the database)
+- **`'stored'`**: The value is computed and stored in the database (takes up space but faster queries)
+
+Both types affect the SQL schema and create actual database columns.
+
+Example:
+
+```ts
+{
+    name: 'Product',
+    fields: [
+        {
+            name: 'price',
+            type: 'Float',
+        },
+        {
+            name: 'quantity',
+            type: 'Int',
+        },
+        {
+            name: 'totalPrice',
+            type: 'Float',
+            generateAs: {
+                expression: 'price * quantity',
+                type: 'stored'
+            }
+        }
+    ]
+}
+```
+
+This creates a `totalPrice` column in the database that is automatically computed as `price * quantity`. The expression can reference other columns in the same table.
+
+#### `type: 'expression'`
+
+This type creates a field that is **not** stored in the database schema. Instead, the expression is evaluated at query time during SELECT operations. This is useful for:
+
+- Computed fields that don't need to be stored
+- Fields that reference columns but shouldn't create database columns
+- Dynamic calculations that should always use the latest data
+
+Example:
+
+```ts
+{
+    name: 'Product',
+    fields: [
+        {
+            name: 'price',
+            type: 'Float',
+        },
+        {
+            name: 'quantity',
+            type: 'Int',
+        },
+        {
+            name: 'totalPrice',
+            type: 'Float',
+            generateAs: {
+                expression: 'price * quantity',
+                type: 'expression'
+            },
+            filterable: true,
+            comparable: true,
+            orderable: true
+        }
+    ]
+}
+```
+
+This creates a `totalPrice` field that is computed at query time. The expression can reference other columns in the table, and column names in the expression are automatically resolved with proper table aliases.
+
+**Important notes for `type: 'expression'`:**
+
+- The field does **not** create a database column
+- The expression is evaluated during SELECT queries
+- Column references in the expression are automatically prefixed with the table alias
+- Can be combined with `filterable`, `comparable`, `orderable`, and `searchable` options
+- Works with all filter types (equality, arrays, null checks, comparisons)
+
+**Expression examples:**
+
+```ts
+// Simple calculation
+{
+    name: 'totalPrice',
+    type: 'Float',
+    generateAs: {
+        expression: 'price * quantity',
+        type: 'expression'
+    }
+}
+
+// Using SQL functions
+{
+    name: 'fullName',
+    type: 'String',
+    generateAs: {
+        expression: "COALESCE(firstName || ' ' || lastName, 'Unknown')",
+        type: 'expression'
+    }
+}
+
+// Conditional logic
+{
+    name: 'discountedPrice',
+    type: 'Float',
+    generateAs: {
+        expression: 'CASE WHEN discount > 0 THEN price * (1 - discount) ELSE price END',
+        type: 'expression'
+    }
+}
+```
+
+**Filtering expression fields:**
+
+When `filterable: true` is set on an expression field, you can filter by it:
+
+```graphql
+query {
+  products(where: { totalPrice_GT: 100 }) {
+    totalPrice
+  }
+}
+```
+
+**Ordering expression fields:**
+
+When `orderable: true` is set on an expression field, you can order by it:
+
+```graphql
+query {
+  products(orderBy: [{ totalPrice: DESC }]) {
+    totalPrice
+  }
+}
+```

package/docs/docs/5-migrations.md

@@ -20,9 +20,17 @@ Note: if you are in a `feat/<feature-name>` branch, the script will use that as
 
 This will generate a migration file in the `migrations` folder (without running the migration itself yet). Check whether it needs to be adapted.
 
+### Generated columns
+
+Fields with `generateAs` are handled specially in migrations:
+
+- **`type: 'virtual'` or `type: 'stored'`**: These create SQL `GENERATED ALWAYS AS` columns in the database. The migration generator will create these columns automatically.
+
+- **`type: 'expression'`**: These fields do **not** create database columns. They are computed at query time and will not appear in migration files. This means you can add or remove expression fields without needing a migration.
+
 ## Running migrations
 
-Migrations themselves are managed with `knex` (see the [knex migration docs](https://knexjs.org/guide/migrations.html)). 
+Migrations themselves are managed with `knex` (see the [knex migration docs](https://knexjs.org/guide/migrations.html)).
 
 For example, to migrate to the latest version (using `env-cmd` to add db connection variables in `.env`):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartive/graphql-magic",
-  "version": "23.4.1",
+  "version": "23.5.0-next.2",
   "description": "",
   "repository": {
     "type": "git",
@@ -68,7 +68,7 @@
     "knex": "^3.0.1"
   },
   "devDependencies": {
-    "@smartive/eslint-config": "7.0.0",
+    "@smartive/eslint-config": "7.0.1",
     "@smartive/prettier-config": "3.1.2",
     "@types/jest": "30.0.0",
     "@types/lodash": "4.17.23",

package/src/bin/gqm/gqm.ts

@@ -12,8 +12,11 @@ import {
   getMigrationDate,
   printSchemaFromModels,
 } from '../..';
+import { generateFunctionsFromDatabase } from '../../migrations/generate-functions';
+import { updateFunctions } from '../../migrations/update-functions';
 import { DateLibrary } from '../../utils/dates';
 import { generateGraphqlApiTypes, generateGraphqlClientTypes } from './codegen';
+import { parseFunctionsFile } from './parse-functions';
 import { parseKnexfile } from './parse-knexfile';
 import { parseModels } from './parse-models';
 import { generatePermissionTypes } from './permissions';
@@ -76,7 +79,9 @@ program
 
     try {
       const models = await parseModels();
-      const migrations = await new MigrationGenerator(db, models).generate();
+      const functionsPath = await getSetting('functionsPath');
+      const parsedFunctions = parseFunctionsFile(functionsPath);
+      const migrations = await new MigrationGenerator(db, models, parsedFunctions).generate();
 
       writeToFile(`migrations/${date || getMigrationDate()}_${name}.ts`, migrations);
     } finally {
@@ -93,7 +98,9 @@ program
 
     try {
       const models = await parseModels();
-      const mg = new MigrationGenerator(db, models);
+      const functionsPath = await getSetting('functionsPath');
+      const parsedFunctions = parseFunctionsFile(functionsPath);
+      const mg = new MigrationGenerator(db, models, parsedFunctions);
       await mg.generate();
 
       if (mg.needsMigration) {
@@ -106,10 +113,42 @@ program
   });
 
 program
-  .command('*', { noHelp: true })
+  .command('generate-functions')
+  .description('Generate functions.ts file from database')
+  .action(async () => {
+    const knexfile = await parseKnexfile();
+    const db = knex(knexfile);
+
+    try {
+      const functionsPath = await getSetting('functionsPath');
+      const functions = await generateFunctionsFromDatabase(db);
+      writeToFile(functionsPath, functions);
+    } finally {
+      await db.destroy();
+    }
+  });
+
+program
+  .command('update-functions')
+  .description('Update database functions from functions.ts file')
+  .action(async () => {
+    const knexfile = await parseKnexfile();
+    const db = knex(knexfile);
+
+    try {
+      const functionsPath = await getSetting('functionsPath');
+      const parsedFunctions = parseFunctionsFile(functionsPath);
+      await updateFunctions(db, parsedFunctions);
+    } finally {
+      await db.destroy();
+    }
+  });
+
+program
+  .command('*')
   .description('Invalid command')
-  .action(() => {
-    console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
+  .action((command) => {
+    console.error(`Invalid command: ${command}\nSee --help for a list of available commands.`);
     process.exit(1);
   });
 

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

@@ -0,0 +1,141 @@
+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/bin/gqm/settings.ts

@@ -39,6 +39,13 @@ const DEFAULTS = {
       ensureFileExists(path, EMPTY_MODELS);
     },
   },
+  functionsPath: {
+    question: 'What is the PostgreSQL functions file path?',
+    defaultValue: 'src/config/functions.ts',
+    init: (path: string) => {
+      ensureFileExists(path, `export const functions: string[] = [];\n`);
+    },
+  },
   generatedFolderPath: {
     question: 'What is the path for generated stuff?',
     defaultValue: 'src/generated',

package/src/bin/gqm/utils.ts

@@ -9,6 +9,7 @@ export const findDeclarationInFile = (sourceFile: SourceFile, name: string) => {
   if (!declaration) {
     throw new Error(`No ${name} declaration`);
   }
+
   return declaration;
 };
 

package/src/migrations/generate-functions.ts

@@ -0,0 +1,74 @@
+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`;
+};