zenstackhq · ymc9 · Oct 1, 2023 · Oct 1, 2023
diff --git a/packages/language/src/generated/ast.ts b/packages/language/src/generated/ast.ts
diff --git a/packages/language/src/generated/grammar.ts b/packages/language/src/generated/grammar.ts
diff --git a/packages/language/src/zmodel.langium b/packages/language/src/zmodel.langium
@@ -15,17 +15,14 @@ AbstractDeclaration:
 
 // datasource
 DataSource:
-    TRIPLE_SLASH_COMMENT* 'datasource' name=RegularID '{' (fields+=DataSourceField)* '}';
-
-DataSourceField:
-    TRIPLE_SLASH_COMMENT* name=RegularID '=' value=(LiteralExpr | InvocationExpr | ArrayExpr);
+    TRIPLE_SLASH_COMMENT* 'datasource' name=RegularID '{' (fields+=ConfigField)* '}';
 
 // generator
 GeneratorDecl:
-    TRIPLE_SLASH_COMMENT* 'generator' name=RegularID '{' (fields+=GeneratorField)* '}';
+    TRIPLE_SLASH_COMMENT* 'generator' name=RegularID '{' (fields+=ConfigField)* '}';
 
-GeneratorField:
-    TRIPLE_SLASH_COMMENT* name=RegularID '=' value=(LiteralExpr | ArrayExpr);
+ConfigField:
+    TRIPLE_SLASH_COMMENT* name=RegularID '=' value=ConfigExpr;
 
 // plugin
 Plugin:
@@ -53,6 +50,22 @@ LiteralExpr:
 ArrayExpr:
     '[' (items+=Expression (',' items+=Expression)*)? ']';
 
+ConfigInvocationExpr:
+    name=ID ('(' ConfigInvocationArgList ')')?;
+
+fragment ConfigInvocationArgList:
+    args+=ConfigInvocationArg (',' args+=ConfigInvocationArg)*;
+
+ConfigInvocationArg:
+    name=ID ':' value=LiteralExpr;
+
+ConfigArrayExpr:
+    '[' (items+=(LiteralExpr|ConfigInvocationExpr) (',' items+=(LiteralExpr|ConfigInvocationExpr))*)? ']';
+
+// expressions used in configuration fields (e.g. datasource, generator, plugin)
+ConfigExpr:
+    LiteralExpr | InvocationExpr | ConfigArrayExpr;
+
 type ReferenceTarget = FunctionParam | DataModelField | EnumField;
 
 ThisExpr:

diff --git a/packages/schema/package.json b/packages/schema/package.json
@@ -112,6 +112,7 @@
         "zod-validation-error": "^0.2.1"
     },
     "devDependencies": {
+        "@prisma/client": "^4.8.0",
         "@types/async-exit-hook": "^2.0.0",
         "@types/jest": "^29.5.0",
         "@types/node": "^18.0.0",
@@ -132,6 +133,7 @@
         "eslint": "^8.27.0",
         "eslint-plugin-jest": "^27.1.7",
         "jest": "^29.5.0",
+        "prisma": "^4.8.0",
         "renamer": "^4.0.0",
         "rimraf": "^3.0.2",
         "tmp": "^0.2.1",

diff --git a/packages/schema/src/plugins/prisma/prisma-builder.ts b/packages/schema/src/plugins/prisma/prisma-builder.ts
@@ -3,7 +3,7 @@ import indentString from './indent-string';
 /**
  * Field used by datasource and generator declarations.
  */
-export type SimpleField = { name: string; value: string | string[] };
+export type SimpleField = { name: string; text: string };
 
 /**
  * Prisma schema builder
@@ -14,15 +14,8 @@ export class PrismaModel {
     private models: Model[] = [];
     private enums: Enum[] = [];
 
-    addDataSource(
-        name: string,
-        provider: string,
-        url: DataSourceUrl,
-        directUrl?: DataSourceUrl,
-        shadowDatabaseUrl?: DataSourceUrl,
-        restFields: SimpleField[] = []
-    ): DataSource {
-        const ds = new DataSource(name, provider, url, directUrl, shadowDatabaseUrl, restFields);
+    addDataSource(name: string, fields: SimpleField[] = []): DataSource {
+        const ds = new DataSource(name, fields);
         this.datasources.push(ds);
         return ds;
     }
@@ -59,47 +52,24 @@ export class PrismaModel {
 }
 
 export class DataSource {
-    constructor(
-        public name: string,
-        public provider: string,
-        public url: DataSourceUrl,
-        public directUrl?: DataSourceUrl,
-        public shadowDatabaseUrl?: DataSourceUrl,
-        public restFields: SimpleField[] = []
-    ) {}
+    constructor(public name: string, public fields: SimpleField[] = []) {}
 
     toString(): string {
-        const restFields =
-            this.restFields.length > 0
-                ? this.restFields.map((f) => indentString(`${f.name} = ${JSON.stringify(f.value)}`)).join('\n')
-                : '';
         return (
             `datasource ${this.name} {\n` +
-            indentString(`provider="${this.provider}"\n`) +
-            indentString(`url=${this.url}\n`) +
-            (this.directUrl ? indentString(`directUrl=${this.directUrl}\n`) : '') +
-            (this.shadowDatabaseUrl ? indentString(`shadowDatabaseUrl=${this.shadowDatabaseUrl}\n`) : '') +
-            (restFields ? restFields + '\n' : '') +
-            `}`
+            this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join('\n') +
+            `\n}`
         );
     }
 }
 
-export class DataSourceUrl {
-    constructor(public value: string, public isEnv: boolean) {}
-
-    toString(): string {
-        return this.isEnv ? `env("${this.value}")` : `"${this.value}"`;
-    }
-}
-
 export class Generator {
     constructor(public name: string, public fields: SimpleField[]) {}
 
     toString(): string {
         return (
             `generator ${this.name} {\n` +
-            this.fields.map((f) => indentString(`${f.name} = ${JSON.stringify(f.value)}`)).join('\n') +
+            this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join('\n') +
             `\n}`
         );
     }

diff --git a/packages/schema/src/plugins/prisma/schema-generator.ts b/packages/schema/src/plugins/prisma/schema-generator.ts
@@ -1,7 +1,9 @@
 import {
-    ArrayExpr,
     AttributeArg,
     BooleanLiteral,
+    ConfigArrayExpr,
+    ConfigExpr,
+    ConfigInvocationArg,
     DataModel,
     DataModelAttribute,
     DataModelField,
@@ -17,7 +19,6 @@ import {
     isInvocationExpr,
     isLiteralExpr,
     isReferenceExpr,
-    isStringLiteral,
     LiteralExpr,
     Model,
     NumberLiteral,
@@ -29,7 +30,6 @@ import { PRISMA_MINIMUM_VERSION } from '@zenstackhq/runtime';
 import {
     getDMMF,
     getLiteral,
-    getLiteralArray,
     getPrismaVersion,
     PluginError,
     PluginOptions,
@@ -51,7 +51,6 @@ import {
     AttributeArgValue as PrismaAttributeArgValue,
     ContainerDeclaration as PrismaContainerDeclaration,
     Model as PrismaDataModel,
-    DataSourceUrl as PrismaDataSourceUrl,
     Enum as PrismaEnum,
     FieldAttribute as PrismaFieldAttribute,
     FieldReference as PrismaFieldReference,
@@ -163,106 +162,67 @@ export default class PrismaSchemaGenerator {
     }
 
     private generateDataSource(prisma: PrismaModel, dataSource: DataSource) {
-        let provider: string | undefined = undefined;
-        let url: PrismaDataSourceUrl | undefined = undefined;
-        let directUrl: PrismaDataSourceUrl | undefined = undefined;
-        let shadowDatabaseUrl: PrismaDataSourceUrl | undefined = undefined;
-        const restFields: SimpleField[] = [];
-
-        for (const f of dataSource.fields) {
-            switch (f.name) {
-                case 'provider': {
-                    if (isStringLiteral(f.value)) {
-                        provider = f.value.value;
-                    } else {
-                        throw new PluginError(name, 'Datasource provider must be set to a string');
-                    }
-                    break;
-                }
-
-                case 'url': {
-                    const r = this.extractDataSourceUrl(f.value);
-                    if (!r) {
-                        throw new PluginError(name, 'Invalid value for datasource url');
-                    }
-                    url = r;
-                    break;
-                }
-
-                case 'directUrl': {
-                    const r = this.extractDataSourceUrl(f.value);
-                    if (!r) {
-                        throw new PluginError(name, 'Invalid value for directUrl');
-                    }
-                    directUrl = r;
-                    break;
-                }
+        const fields: SimpleField[] = dataSource.fields.map((f) => ({
+            name: f.name,
+            text: this.configExprToText(f.value),
+        }));
+        prisma.addDataSource(dataSource.name, fields);
+    }
 
-                case 'shadowDatabaseUrl': {
-                    const r = this.extractDataSourceUrl(f.value);
-                    if (!r) {
-                        throw new PluginError(name, 'Invalid value for shadowDatabaseUrl');
-                    }
-                    shadowDatabaseUrl = r;
-                    break;
-                }
+    private configExprToText(expr: ConfigExpr) {
+        if (isLiteralExpr(expr)) {
+            return this.literalToText(expr);
+        } else if (isInvocationExpr(expr)) {
+            const fc = this.makeFunctionCall(expr);
+            return fc.toString();
+        } else {
+            return this.configArrayToText(expr);
+        }
+    }
 
-                default: {
-                    // rest fields
-                    const value = isArrayExpr(f.value) ? getLiteralArray(f.value) : getLiteral(f.value);
-                    if (value === undefined) {
-                        throw new PluginError(
-                            name,
-                            `Invalid value for datasource field ${f.name}: value must be a string or an array of strings`
-                        );
+    private configArrayToText(expr: ConfigArrayExpr) {
+        return (
+            '[' +
+            expr.items
+                .map((item) => {
+                    if (isLiteralExpr(item)) {
+                        return this.literalToText(item);
                     } else {
-                        restFields.push({ name: f.name, value });
+                        return (
+                            item.name +
+                            (item.args.length > 0
+                                ? '(' + item.args.map((arg) => this.configInvocationArgToText(arg)).join(', ') + ')'
+                                : '')
+                        );
                     }
-                    break;
-                }
-            }
-        }
-
-        if (!provider) {
-            throw new PluginError(name, 'Datasource is missing "provider" field');
-        }
-        if (!url) {
-            throw new PluginError(name, 'Datasource is missing "url" field');
-        }
+                })
+                .join(', ') +
+            ']'
+        );
+    }
 
-        prisma.addDataSource(dataSource.name, provider, url, directUrl, shadowDatabaseUrl, restFields);
+    private configInvocationArgToText(arg: ConfigInvocationArg) {
+        return `${arg.name}: ${this.literalToText(arg.value)}`;
     }
 
-    private extractDataSourceUrl(fieldValue: LiteralExpr | InvocationExpr | ArrayExpr) {
-        if (isStringLiteral(fieldValue)) {
-            return new PrismaDataSourceUrl(fieldValue.value, false);
-        } else if (
-            isInvocationExpr(fieldValue) &&
-            fieldValue.function.ref?.name === 'env' &&
-            fieldValue.args.length === 1 &&
-            isStringLiteral(fieldValue.args[0].value)
-        ) {
-            return new PrismaDataSourceUrl(fieldValue.args[0].value.value as string, true);
-        } else {
-            return null;
-        }
+    private literalToText(expr: LiteralExpr) {
+        return JSON.stringify(expr.value);
     }
 
     private generateGenerator(prisma: PrismaModel, decl: GeneratorDecl) {
         const generator = prisma.addGenerator(
             decl.name,
-            decl.fields.map((f) => {
-                const value = isArrayExpr(f.value) ? getLiteralArray(f.value) : getLiteral(f.value);
-                return { name: f.name, value };
-            })
+            decl.fields.map((f) => ({ name: f.name, text: this.configExprToText(f.value) }))
         );
 
         // deal with configuring PrismaClient preview features
         const provider = generator.fields.find((f) => f.name === 'provider');
-        if (provider?.value === 'prisma-client-js') {
+        if (provider?.text === JSON.stringify('prisma-client-js')) {
             const prismaVersion = getPrismaVersion();
             if (prismaVersion) {
-                const previewFeatures = generator.fields.find((f) => f.name === 'previewFeatures')?.value ?? [];
+                const previewFeatures = JSON.parse(
+                    generator.fields.find((f) => f.name === 'previewFeatures')?.text ?? '[]'
+                );
 
                 if (!Array.isArray(previewFeatures)) {
                     throw new PluginError(name, 'option "previewFeatures" must be an array');
@@ -285,7 +245,9 @@ export default class PrismaSchemaGenerator {
                 if (previewFeatures.length > 0) {
                     const curr = generator.fields.find((f) => f.name === 'previewFeatures');
                     if (!curr) {
-                        generator.fields.push({ name: 'previewFeatures', value: previewFeatures });
+                        generator.fields.push({ name: 'previewFeatures', text: JSON.stringify(previewFeatures) });
+                    } else {
+                        curr.text = JSON.stringify(previewFeatures);
                     }
                 }
             }

diff --git a/packages/schema/tests/generator/prisma-builder.test.ts b/packages/schema/tests/generator/prisma-builder.test.ts
@@ -2,7 +2,6 @@ import { getDMMF } from '@zenstackhq/sdk';
 import {
     AttributeArg,
     AttributeArgValue,
-    DataSourceUrl,
     FieldAttribute,
     FieldReference,
     FieldReferenceArg,
@@ -25,15 +24,17 @@ async function validate(model: PrismaModel) {
 describe('Prisma Builder Tests', () => {
     it('datasource', async () => {
         let model = new PrismaModel();
-        model.addDataSource('db', 'postgresql', new DataSourceUrl('DATABASE_URL', true));
+        model.addDataSource('db', [
+            { name: 'provider', text: '"postgresql"' },
+            { name: 'url', text: 'env("DATABASE_URL")' },
+        ]);
         await validate(model);
 
         model = new PrismaModel();
-        model.addDataSource(
-            'db',
-            'postgresql',
-            new DataSourceUrl('postgresql://postgres:abc123@localhost:5432/sample?schema=public', false)
-        );
+        model.addDataSource('db', [
+            { name: 'provider', text: '"postgresql"' },
+            { name: 'url', text: '"postgresql://postgres:abc123@localhost:5432/sample?schema=public"' },
+        ]);
         await validate(model);
     });
 
@@ -47,7 +48,7 @@ describe('Prisma Builder Tests', () => {
 
     it('generator', async () => {
         const model = new PrismaModel();
-        model.addGenerator('client', [{ name: 'provider', value: 'prisma-client-js' }]);
+        model.addGenerator('client', [{ name: 'provider', text: '"prisma-client-js"' }]);
         await validate(model);
     });