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

package/docs/docs/3-fields.md

@@ -341,152 +341,3 @@ 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,17 +20,9 @@ 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.0-next.8",
+  "version": "23.4.1",
   "description": "",
   "repository": {
     "type": "git",
@@ -77,7 +77,7 @@
     "conventional-changelog-conventionalcommits": "9.1.0",
     "create-ts-index": "1.14.0",
     "del-cli": "7.0.0",
-    "esbuild": "0.27.2",
+    "esbuild": "0.27.3",
     "eslint": "9.39.2",
     "jest": "30.2.0",
     "mock-knex": "0.4.13",

package/src/bin/gqm/gqm.ts

@@ -12,11 +12,8 @@ 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';
@@ -79,9 +76,7 @@ program
 
     try {
       const models = await parseModels();
-      const functionsPath = await getSetting('functionsPath');
-      const parsedFunctions = parseFunctionsFile(functionsPath);
-      const migrations = await new MigrationGenerator(db, models, parsedFunctions).generate();
+      const migrations = await new MigrationGenerator(db, models).generate();
 
       writeToFile(`migrations/${date || getMigrationDate()}_${name}.ts`, migrations);
     } finally {
@@ -98,9 +93,7 @@ program
 
     try {
       const models = await parseModels();
-      const functionsPath = await getSetting('functionsPath');
-      const parsedFunctions = parseFunctionsFile(functionsPath);
-      const mg = new MigrationGenerator(db, models, parsedFunctions);
+      const mg = new MigrationGenerator(db, models);
       await mg.generate();
 
       if (mg.needsMigration) {
@@ -113,42 +106,10 @@ program
   });
 
 program
-  .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('*')
+  .command('*', { noHelp: true })
   .description('Invalid command')
-  .action((command) => {
-    console.error(`Invalid command: ${command}\nSee --help for a list of available commands.`);
+  .action(() => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
     process.exit(1);
   });
 

package/src/bin/gqm/settings.ts

@@ -39,13 +39,6 @@ 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/static-eval.ts

@@ -4,10 +4,12 @@ import {
   CaseClause,
   ElementAccessExpression,
   Identifier,
+  ImportSpecifier,
   Node,
   ObjectLiteralExpression,
   PrefixUnaryExpression,
   ShorthandPropertyAssignment,
+  StringLiteral,
   SyntaxKind,
   TemplateExpression,
   TemplateTail,
@@ -77,6 +79,106 @@ const VISITOR: Visitor<unknown, Dictionary<unknown>> = {
   }),
   [SyntaxKind.SpreadElement]: (node, context) => staticEval(node.getExpression(), context),
   [SyntaxKind.SpreadAssignment]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.ImportSpecifier]: (node: ImportSpecifier, context) => {
+    const nameNode = node.getNameNode();
+    const name = nameNode.getText();
+
+    if (name in KNOWN_IDENTIFIERS) {
+      return KNOWN_IDENTIFIERS[name];
+    }
+
+    if (nameNode instanceof StringLiteral) {
+      throw new Error(`Cannot handle computed import specifier: ${name}. Only static imports are supported.`);
+    }
+
+    const definitions = nameNode.getDefinitionNodes();
+    // Filter out the node itself to prevent infinite recursion
+    // We compare compilerNode references to handle distinct ts-morph wrapper instances
+    let externalDefinition = definitions.find((d) => d.compilerNode !== node.compilerNode);
+
+    // Fallback: If definition navigation fails (e.g. path aliases), try resolving module manually
+    if (!externalDefinition) {
+      const importDeclaration = node.getImportDeclaration();
+      let sourceFile = importDeclaration.getModuleSpecifierSourceFile();
+
+      // If ts-morph failed to find the file (common with aliases without project config), try manual lookup
+      if (!sourceFile) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        const project = node.getProject();
+
+        if (moduleSpecifier.startsWith('@/')) {
+          const suffix = moduleSpecifier.substring(2);
+
+          // 1. Check if the file is already loaded in the project
+          sourceFile = project.getSourceFiles().find((sf) => {
+            const filePath = sf.getFilePath();
+            // Check for direct match or index file
+            return (
+              filePath.endsWith(`/${suffix}.ts`) ||
+              filePath.endsWith(`/${suffix}.tsx`) ||
+              filePath.endsWith(`/${suffix}/index.ts`) ||
+              filePath.endsWith(`/${suffix}/index.tsx`)
+            );
+          });
+
+          // 2. If not loaded, try to find and add it from disk (heuristic: @/ -> src/)
+          if (!sourceFile) {
+            const candidates = [
+              `src/${suffix}.ts`,
+              `src/${suffix}.tsx`,
+              `src/${suffix}/index.ts`,
+              `src/${suffix}/index.tsx`,
+            ];
+
+            for (const candidate of candidates) {
+              try {
+                // addSourceFileAtPathIfExists resolves relative to CWD
+                const added = project.addSourceFileAtPathIfExists(candidate);
+                if (added) {
+                  sourceFile = added;
+                  break;
+                }
+              } catch {
+                // Ignore load errors
+              }
+            }
+          }
+        }
+      }
+
+      if (sourceFile) {
+        // Use property path if aliased (import { RealName as Alias }), otherwise name
+        // The import specifier is { propertyName as name }
+        // If propertyName is undefined, then propertyName is name
+        // We want the original propertyName to look up exports
+        const localName = node.getName();
+        const propertyName = node.compilerNode.propertyName?.getText();
+        const exportedName = propertyName ?? localName;
+
+        const exportedDeclarations = sourceFile.getExportedDeclarations();
+        const declarations = exportedDeclarations.get(exportedName);
+        const declaration = declarations?.[0];
+
+        if (declaration) {
+          externalDefinition = declaration;
+        }
+      }
+    }
+
+    // Handle re-exports: if the definition is another ImportSpecifier (in a different file), recurse
+    if (externalDefinition && externalDefinition.getKind() === SyntaxKind.ImportSpecifier) {
+      return staticEval(externalDefinition, context);
+    }
+
+    if (!externalDefinition) {
+      const importDeclaration = node.getImportDeclaration();
+      throw new Error(
+        `No definition node found for import specifier '${name}' imported from '${importDeclaration.getModuleSpecifierValue()}'.`,
+      );
+    }
+
+    return staticEval(externalDefinition, context);
+  },
   [SyntaxKind.Identifier]: (node: Identifier, context) => {
     const identifierName = node.getText();
     if (identifierName in KNOWN_IDENTIFIERS) {

package/src/bin/gqm/utils.ts

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