Merge dev branch and remove SQLite URL redaction

Co-authored-by: ymc9 <104139426+ymc9@users.noreply.github.com>

Author: Copilot

packages/cli/package.json

@@ -46,11 +46,13 @@
         "colors": "1.4.0",
         "commander": "^8.3.0",
         "cors": "^2.8.5",
+        "dotenv": "^17.2.3",
         "execa": "^9.6.0",
         "express": "^5.0.0",
         "jiti": "^2.6.1",
         "langium": "catalog:",
         "mixpanel": "^0.18.1",
+        "mysql2": "catalog:",
         "ora": "^5.4.1",
         "package-manager-detector": "^1.3.0",
         "pg": "catalog:",

packages/cli/src/actions/proxy.ts

@@ -120,7 +120,7 @@ function redactDatabaseUrl(url: string): string {
         }
         return parsedUrl.toString();
     } catch {
-        // If URL parsing fails, return the original (might be a file path for SQLite)
+        // If URL parsing fails, return the original
         return url;
     }
 }
@@ -135,7 +135,7 @@ function createDialect(provider: string, databaseUrl: string, outputPath: string
                     resolvedUrl = path.join(outputPath, filePath);
                 }
             }
-            console.log(colors.gray(`Connecting to SQLite database at: ${redactDatabaseUrl(resolvedUrl)}`));
+            console.log(colors.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
             return new SqliteDialect({
                 database: new SQLite(resolvedUrl),
             });

packages/cli/src/index.ts

@@ -1,3 +1,4 @@
+import 'dotenv/config';
 import { ZModelLanguageMetaData } from '@zenstackhq/language';
 import colors from 'colors';
 import { Command, CommanderError, Option } from 'commander';

packages/cli/src/utils/exec-utils.ts

@@ -57,5 +57,5 @@ export function execPrisma(args: string, options?: Omit<ExecSyncOptions, 'env'>
         return;
     }
 
-    execSync(`node ${prismaPath} ${args}`, _options);
+    execSync(`node "${prismaPath}" ${args}`, _options);
 }

packages/language/src/utils.ts

@@ -104,9 +104,7 @@ export function typeAssignable(destType: ExpressionType, sourceType: ExpressionT
 /**
  * Maps a ZModel builtin type to expression type
  */
-export function mapBuiltinTypeToExpressionType(
-    type: BuiltinType | ExpressionType,
-): ExpressionType {
+export function mapBuiltinTypeToExpressionType(type: BuiltinType | ExpressionType): ExpressionType {
     switch (type) {
         case 'Any':
         case 'Boolean':
@@ -170,6 +168,7 @@ export function resolved<T extends AstNode>(ref: Reference<T>): T {
 export function getRecursiveBases(
     decl: DataModel | TypeDef,
     includeDelegate = true,
+    documents?: LangiumDocuments,
     seen = new Set<DataModel | TypeDef>(),
 ): (TypeDef | DataModel)[] {
     const result: (TypeDef | DataModel)[] = [];
@@ -179,16 +178,28 @@ export function getRecursiveBases(
     seen.add(decl);
     const bases = [...decl.mixins, ...(isDataModel(decl) && decl.baseModel ? [decl.baseModel] : [])];
     bases.forEach((base) => {
-        // avoid using .ref since this function can be called before linking
-        const baseDecl = decl.$container.declarations.find(
-            (d): d is TypeDef | DataModel => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText,
-        );
+        let baseDecl: TypeDef | DataModel | undefined;
+
+        if (base.ref && (isTypeDef(base.ref) || isDataModel(base.ref))) {
+            // base is already resolved
+            baseDecl = base.ref;
+        } else {
+            // otherwise, search by name, in all imported documents if provided
+            const declarations = documents
+                ? getAllDeclarationsIncludingImports(documents, decl.$container)
+                : decl.$container.declarations;
+
+            baseDecl = declarations.find(
+                (d): d is TypeDef | DataModel => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText,
+            );
+        }
+
         if (baseDecl) {
             if (!includeDelegate && isDelegateModel(baseDecl)) {
                 return;
             }
             result.push(baseDecl);
-            result.push(...getRecursiveBases(baseDecl, includeDelegate, seen));
+            result.push(...getRecursiveBases(baseDecl, includeDelegate, documents, seen));
         }
     });
     return result;

packages/language/src/zmodel-scope.ts

@@ -80,7 +80,7 @@ export class ZModelScopeComputation extends DefaultScopeComputation {
         super.processNode(node, document, scopes);
         if (isDataModel(node) || isTypeDef(node)) {
             // add base fields to the scope recursively
-            const bases = getRecursiveBases(node);
+            const bases = getRecursiveBases(node, true, this.services.shared.workspace.LangiumDocuments);
             for (const base of bases) {
                 for (const field of base.fields) {
                     scopes.add(node, this.descriptions.createDescription(field, this.nameProvider.getName(field)));

packages/language/test/mixin.test.ts

@@ -1,6 +1,12 @@
+import { invariant } from '@zenstackhq/common-helpers';
+import fs from 'node:fs';
+import path from 'node:path';
+import tmp from 'tmp';
 import { describe, expect, it } from 'vitest';
-import { loadSchema, loadSchemaWithError } from './utils';
+import { loadDocument } from '../src';
 import { DataModel, TypeDef } from '../src/ast';
+import { getAllFields } from '../src/utils';
+import { loadSchema, loadSchemaWithError } from './utils';
 
 describe('Mixin Tests', () => {
     it('supports model mixing types to Model', async () => {
@@ -136,4 +142,95 @@ describe('Mixin Tests', () => {
             'Type field cannot be a relation',
         );
     });
+
+    it('supports mixin fields from imported file', async () => {
+        const { name } = tmp.dirSync();
+
+        fs.writeFileSync(
+            path.join(name, 'base.zmodel'),
+            `
+type Timestamped {
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+}
+            `,
+        );
+
+        fs.writeFileSync(
+            path.join(name, 'main.zmodel'),
+            `
+import './base'
+
+datasource db {
+    provider = 'sqlite'
+    url = 'file:./dev.db'
+}
+
+model Post with Timestamped {
+    id String @id
+    title String
+}
+            `,
+        );
+
+        const model = await expectLoaded(path.join(name, 'main.zmodel'));
+        const post = model.declarations.find((d) => d.name === 'Post') as DataModel;
+        expect(post.mixins[0].ref?.name).toBe('Timestamped');
+
+        // Verify fields from imported mixin are accessible
+        const allFields = getAllFields(post);
+        expect(allFields.map((f) => f.name)).toContain('createdAt');
+        expect(allFields.map((f) => f.name)).toContain('updatedAt');
+    });
+
+    it('can reference imported mixin fields in policy rules', async () => {
+        const { name } = tmp.dirSync();
+
+        fs.writeFileSync(
+            path.join(name, 'base.zmodel'),
+            `
+type Owned {
+    ownerId String
+}
+            `,
+        );
+
+        fs.writeFileSync(
+            path.join(name, 'main.zmodel'),
+            `
+import './base'
+
+datasource db {
+    provider = 'sqlite'
+    url = 'file:./dev.db'
+}
+
+model User {
+    id String @id
+    @@auth()
+}
+
+model Post with Owned {
+    id String @id
+
+    @@allow('update', auth().id == ownerId)
+}
+            `,
+        );
+
+        // If this loads without "Could not resolve reference" error, the fix works
+        const model = await expectLoaded(path.join(name, 'main.zmodel'));
+        expect(model).toBeDefined();
+    });
+
+    async function expectLoaded(file: string) {
+        const pluginDocs = [path.resolve(__dirname, '../../plugins/policy/plugin.zmodel')];
+        const result = await loadDocument(file, pluginDocs);
+        if (!result.success) {
+            console.error('Errors:', result.errors);
+            throw new Error(`Failed to load document from ${file}`);
+        }
+        invariant(result.success);
+        return result.model;
+    }
 });

packages/orm/src/client/crud/dialects/base-dialect.ts

@@ -489,26 +489,41 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
                 continue;
             }
 
-            const value = this.transformInput(_value, fieldType, !!fieldDef.array);
+            invariant(fieldDef.array, 'Field must be an array type to build array filter');
+            const value = this.transformInput(_value, fieldType, true);
+
+            let receiver = fieldRef;
+            if (isEnum(this.schema, fieldType)) {
+                // cast enum array to `text[]` for type compatibility
+                receiver = this.eb.cast(fieldRef, sql.raw('text[]'));
+            }
+
+            const buildArray = (value: unknown) => {
+                invariant(Array.isArray(value), 'Array filter value must be an array');
+                return this.buildArrayValue(
+                    value.map((v) => this.eb.val(v)),
+                    fieldType,
+                );
+            };
 
             switch (key) {
                 case 'equals': {
-                    clauses.push(this.buildLiteralFilter(fieldRef, fieldType, this.eb.val(value)));
+                    clauses.push(this.eb(receiver, '=', buildArray(value)));
                     break;
                 }
 
                 case 'has': {
-                    clauses.push(this.eb(fieldRef, '@>', this.eb.val([value])));
+                    clauses.push(this.buildArrayContains(receiver, this.eb.val(value)));
                     break;
                 }
 
                 case 'hasEvery': {
-                    clauses.push(this.eb(fieldRef, '@>', this.eb.val(value)));
+                    clauses.push(this.buildArrayHasEvery(receiver, buildArray(value)));
                     break;
                 }
 
                 case 'hasSome': {
-                    clauses.push(this.eb(fieldRef, '&&', this.eb.val(value)));
+                    clauses.push(this.buildArrayHasSome(receiver, buildArray(value)));
                     break;
                 }
 
@@ -1420,9 +1435,24 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
     abstract buildArrayLength(array: Expression<unknown>): AliasableExpression<number>;
 
     /**
-     * Builds an array literal SQL string for the given values.
+     * Builds an array value expression.
      */
-    abstract buildArrayLiteralSQL(values: unknown[]): AliasableExpression<unknown>;
+    abstract buildArrayValue(values: Expression<unknown>[], elemType: string): AliasableExpression<unknown>;
+
+    /**
+     * Builds an expression that checks if an array contains a single value.
+     */
+    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>): AliasableExpression<SqlBool>;
+
+    /**
+     * Builds an expression that checks if an array contains all values from another array.
+     */
+    abstract buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
+
+    /**
+     * Builds an expression that checks if an array overlaps with another array.
+     */
+    abstract buildArrayHasSome(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
 
     /**
      * Casts the given expression to an integer type.
@@ -1439,11 +1469,6 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
      */
     abstract trimTextQuotes<T extends Expression<string>>(expression: T): T;
 
-    /**
-     * Gets the SQL column type for the given field definition.
-     */
-    abstract getFieldSqlType(fieldDef: FieldDef): string;
-
     /*
      * Gets the string casing behavior for the dialect.
      */

packages/orm/src/client/crud/dialects/mysql.ts

@@ -3,17 +3,18 @@ import Decimal from 'decimal.js';
 import type { AliasableExpression, TableExpression } from 'kysely';
 import {
     expressionBuilder,
+    ExpressionWrapper,
     sql,
+    ValueListNode,
     type Expression,
-    type ExpressionWrapper,
     type SelectQueryBuilder,
     type SqlBool,
 } from 'kysely';
 import { match } from 'ts-pattern';
 import { AnyNullClass, DbNullClass, JsonNullClass } from '../../../common-types';
 import type { BuiltinType, FieldDef, SchemaDef } from '../../../schema';
 import type { SortOrder } from '../../crud-types';
-import { createInternalError, createInvalidInputError, createNotSupportedError } from '../../errors';
+import { createInvalidInputError, createNotSupportedError } from '../../errors';
 import type { ClientOptions } from '../../options';
 import { isTypeDef } from '../../query-utils';
 import { LateralJoinDialectBase } from './lateral-join-dialect-base';
@@ -223,8 +224,29 @@ export class MySqlCrudDialect<Schema extends SchemaDef> extends LateralJoinDiale
         return this.eb.fn('JSON_LENGTH', [array]);
     }
 
-    override buildArrayLiteralSQL(_values: unknown[]): AliasableExpression<number> {
-        throw new Error('MySQL does not support array literals');
+    override buildArrayValue(values: Expression<unknown>[], _elemType: string): AliasableExpression<unknown> {
+        return new ExpressionWrapper(ValueListNode.create(values.map((v) => v.toOperationNode())));
+    }
+
+    override buildArrayContains(
+        _field: Expression<unknown>,
+        _value: Expression<unknown>,
+    ): AliasableExpression<SqlBool> {
+        throw createNotSupportedError('MySQL does not support native array operations');
+    }
+
+    override buildArrayHasEvery(
+        _field: Expression<unknown>,
+        _values: Expression<unknown>,
+    ): AliasableExpression<SqlBool> {
+        throw createNotSupportedError('MySQL does not support native array operations');
+    }
+
+    override buildArrayHasSome(
+        _field: Expression<unknown>,
+        _values: Expression<unknown>,
+    ): AliasableExpression<SqlBool> {
+        throw createNotSupportedError('MySQL does not support native array operations');
     }
 
     protected override buildJsonEqualityFilter(
@@ -288,40 +310,6 @@ export class MySqlCrudDialect<Schema extends SchemaDef> extends LateralJoinDiale
         );
     }
 
-    override getFieldSqlType(fieldDef: FieldDef) {
-        // TODO: respect `@db.x` attributes
-        if (fieldDef.relation) {
-            throw createInternalError('Cannot get SQL type of a relation field');
-        }
-
-        let result: string;
-
-        if (this.schema.enums?.[fieldDef.type]) {
-            // enums are treated as text/varchar
-            result = 'varchar(255)';
-        } else {
-            result = match(fieldDef.type)
-                .with('String', () => 'varchar(255)')
-                .with('Boolean', () => 'tinyint(1)') // MySQL uses tinyint(1) for boolean
-                .with('Int', () => 'int')
-                .with('BigInt', () => 'bigint')
-                .with('Float', () => 'double')
-                .with('Decimal', () => 'decimal')
-                .with('DateTime', () => 'datetime')
-                .with('Bytes', () => 'blob')
-                .with('Json', () => 'json')
-                // fallback to text
-                .otherwise(() => 'text');
-        }
-
-        if (fieldDef.array) {
-            // MySQL stores arrays as JSON
-            result = 'json';
-        }
-
-        return result;
-    }
-
     override getStringCasingBehavior() {
         // MySQL LIKE is case-insensitive by default (depends on collation), no ILIKE support
         return { supportsILike: false, likeCaseSensitive: false };