zenstack 0.1.47 → 0.1.50

package/src/generator/prisma/schema-generator.ts

@@ -0,0 +1,305 @@
+import {
+    AttributeArg,
+    DataModel,
+    DataModelAttribute,
+    DataModelField,
+    DataModelFieldAttribute,
+    DataSource,
+    Enum,
+    Expression,
+    InvocationExpr,
+    isArrayExpr,
+    isInvocationExpr,
+    isLiteralExpr,
+    isReferenceExpr,
+    LiteralExpr,
+} from '@lang/generated/ast';
+import { writeFile } from 'fs/promises';
+import { AstNode } from 'langium';
+import path from 'path';
+import { GUARD_FIELD_NAME, TRANSACTION_FIELD_NAME } from '../constants';
+import { Context, GeneratorError } from '../types';
+import { resolved } from '../utils';
+import {
+    AttributeArg as PrismaAttributeArg,
+    AttributeArgValue as PrismaAttributeArgValue,
+    DataSourceUrl as PrismaDataSourceUrl,
+    FieldAttribute as PrismaFieldAttribute,
+    ModelAttribute as PrismaModelAttribute,
+    Model as PrismaDataModel,
+    FieldReference as PrismaFieldReference,
+    FieldReferenceArg as PrismaFieldReferenceArg,
+    FunctionCall as PrismaFunctionCall,
+    FunctionCallArg as PrismaFunctionCallArg,
+    PrismaModel,
+    ModelFieldType,
+} from './prisma-builder';
+
+const excludedAttributes = ['@@allow', '@@deny'];
+
+/**
+ * Generates Prisma schema file
+ */
+export default class PrismaSchemaGenerator {
+    constructor(private readonly context: Context) {}
+
+    async generate(): Promise<string> {
+        const { schema } = this.context;
+        const prisma = new PrismaModel();
+
+        for (const decl of schema.declarations) {
+            switch (decl.$type) {
+                case DataSource:
+                    this.generateDataSource(prisma, decl as DataSource);
+                    break;
+
+                case Enum:
+                    this.generateEnum(prisma, decl as Enum);
+                    break;
+
+                case DataModel:
+                    this.generateModel(prisma, decl as DataModel);
+                    break;
+            }
+        }
+
+        this.generateGenerator(prisma);
+
+        const outFile = path.join(this.context.outDir, 'schema.prisma');
+        await writeFile(outFile, prisma.toString());
+        return outFile;
+    }
+
+    private generateDataSource(prisma: PrismaModel, dataSource: DataSource) {
+        let provider: string | undefined = undefined;
+        let url: PrismaDataSourceUrl | undefined = undefined;
+        let shadowDatabaseUrl: PrismaDataSourceUrl | undefined = undefined;
+
+        for (const f of dataSource.fields) {
+            switch (f.name) {
+                case 'provider': {
+                    if (this.isStringLiteral(f.value)) {
+                        provider = f.value.value as string;
+                    } else {
+                        throw new GeneratorError(
+                            'Datasource provider must be set to a string'
+                        );
+                    }
+                    break;
+                }
+
+                case 'url': {
+                    const r = this.extractDataSourceUrl(f.value);
+                    if (!r) {
+                        throw new GeneratorError(
+                            'Invalid value for datasource url'
+                        );
+                    }
+                    url = r;
+                    break;
+                }
+
+                case 'shadowDatabaseUrl': {
+                    const r = this.extractDataSourceUrl(f.value);
+                    if (!r) {
+                        throw new GeneratorError(
+                            'Invalid value for datasource url'
+                        );
+                    }
+                    shadowDatabaseUrl = r;
+                    break;
+                }
+            }
+        }
+
+        if (!provider) {
+            throw new GeneratorError('Datasource is missing "provider" field');
+        }
+        if (!url) {
+            throw new GeneratorError('Datasource is missing "url" field');
+        }
+
+        prisma.addDataSource(dataSource.name, provider, url, shadowDatabaseUrl);
+    }
+
+    private extractDataSourceUrl(fieldValue: LiteralExpr | InvocationExpr) {
+        if (this.isStringLiteral(fieldValue)) {
+            return new PrismaDataSourceUrl(fieldValue.value as string, false);
+        } else if (
+            isInvocationExpr(fieldValue) &&
+            fieldValue.function.ref?.name === 'env' &&
+            fieldValue.args.length === 1 &&
+            this.isStringLiteral(fieldValue.args[0].value)
+        ) {
+            return new PrismaDataSourceUrl(
+                fieldValue.args[0].value.value as string,
+                true
+            );
+        } else {
+            return null;
+        }
+    }
+
+    private generateGenerator(prisma: PrismaModel) {
+        prisma.addGenerator(
+            'client',
+            'prisma-client-js',
+            path.join('../', this.context.generatedCodeDir, '.prisma'),
+            [
+                'fieldReference',
+                'interactiveTransactions',
+                'referentialIntegrity',
+            ]
+        );
+    }
+
+    private generateModel(prisma: PrismaModel, decl: DataModel) {
+        const model = prisma.addModel(decl.name);
+        for (const field of decl.fields) {
+            this.generateModelField(model, field);
+        }
+
+        // add an "zenstack_guard" field for dealing with pure auth() related conditions
+        model.addField(GUARD_FIELD_NAME, 'Boolean', [
+            new PrismaFieldAttribute('@default', [
+                new PrismaAttributeArg(
+                    undefined,
+                    new PrismaAttributeArgValue('Boolean', true)
+                ),
+            ]),
+        ]);
+
+        // add an "zenstack_transaction" field for tracking records created/updated with nested writes
+        model.addField(TRANSACTION_FIELD_NAME, 'String?');
+
+        for (const attr of decl.attributes.filter(
+            (attr) =>
+                attr.decl.ref?.name &&
+                !excludedAttributes.includes(attr.decl.ref.name)
+        )) {
+            this.generateModelAttribute(model, attr);
+        }
+    }
+
+    private generateModelField(model: PrismaDataModel, field: DataModelField) {
+        const fieldType = field.type.type || field.type.reference?.ref?.name;
+        if (!fieldType) {
+            throw new GeneratorError(
+                `Field type is not resolved: ${field.$container.name}.${field.name}`
+            );
+        }
+
+        const type = new ModelFieldType(
+            fieldType,
+            field.type.array,
+            field.type.optional
+        );
+
+        const attributes = field.attributes
+            .filter(
+                (attr) =>
+                    attr.decl.ref?.name &&
+                    !excludedAttributes.includes(attr.decl.ref.name)
+            )
+            .map((attr) => this.makeFieldAttribute(attr));
+        model.addField(field.name, type, attributes);
+    }
+
+    private makeFieldAttribute(attr: DataModelFieldAttribute) {
+        return new PrismaFieldAttribute(
+            resolved(attr.decl).name,
+            attr.args.map((arg) => this.makeAttributeArg(arg))
+        );
+    }
+
+    makeAttributeArg(arg: AttributeArg): PrismaAttributeArg {
+        return new PrismaAttributeArg(
+            arg.name,
+            this.makeAttributeArgValue(arg.value)
+        );
+    }
+
+    makeAttributeArgValue(node: Expression): PrismaAttributeArgValue {
+        if (isLiteralExpr(node)) {
+            switch (typeof node.value) {
+                case 'string':
+                    return new PrismaAttributeArgValue('String', node.value);
+                case 'number':
+                    return new PrismaAttributeArgValue('Number', node.value);
+                case 'boolean':
+                    return new PrismaAttributeArgValue('Boolean', node.value);
+                default:
+                    throw new GeneratorError(
+                        `Unexpected literal type: ${typeof node.value}`
+                    );
+            }
+        } else if (isArrayExpr(node)) {
+            return new PrismaAttributeArgValue(
+                'Array',
+                new Array(
+                    ...node.items.map((item) =>
+                        this.makeAttributeArgValue(item)
+                    )
+                )
+            );
+        } else if (isReferenceExpr(node)) {
+            return new PrismaAttributeArgValue(
+                'FieldReference',
+                new PrismaFieldReference(
+                    resolved(node.target).name,
+                    node.args.map(
+                        (arg) =>
+                            new PrismaFieldReferenceArg(arg.name, arg.value)
+                    )
+                )
+            );
+        } else if (isInvocationExpr(node)) {
+            // invocation
+            return new PrismaAttributeArgValue(
+                'FunctionCall',
+                this.makeFunctionCall(node)
+            );
+        } else {
+            throw new GeneratorError(
+                `Unsupported attribute argument expression type: ${node.$type}`
+            );
+        }
+    }
+
+    makeFunctionCall(node: InvocationExpr): PrismaFunctionCall {
+        return new PrismaFunctionCall(
+            resolved(node.function).name,
+            node.args.map((arg) => {
+                if (!isLiteralExpr(arg.value)) {
+                    throw new GeneratorError(
+                        'Function call argument must be literal'
+                    );
+                }
+                return new PrismaFunctionCallArg(arg.name, arg.value.value);
+            })
+        );
+    }
+
+    private generateModelAttribute(
+        model: PrismaDataModel,
+        attr: DataModelAttribute
+    ) {
+        model.attributes.push(
+            new PrismaModelAttribute(
+                resolved(attr.decl).name,
+                attr.args.map((arg) => this.makeAttributeArg(arg))
+            )
+        );
+    }
+
+    private generateEnum(prisma: PrismaModel, decl: Enum) {
+        prisma.addEnum(
+            decl.name,
+            decl.fields.map((f) => f.name)
+        );
+    }
+
+    private isStringLiteral(node: AstNode): node is LiteralExpr {
+        return isLiteralExpr(node) && typeof node.value === 'string';
+    }
+}

package/src/generator/prisma/typescript-expression-transformer.ts

@@ -0,0 +1,108 @@
+import { GeneratorError } from '../types';
+import {
+    ArrayExpr,
+    Expression,
+    InvocationExpr,
+    isEnumField,
+    isThisExpr,
+    LiteralExpr,
+    MemberAccessExpr,
+    NullExpr,
+    ReferenceExpr,
+    ThisExpr,
+} from '@lang/generated/ast';
+
+/**
+ * Transforms ZModel expression to plain TypeScript expression.
+ */
+export default class TypeScriptExpressionTransformer {
+    /**
+     *
+     * @param expr
+     * @returns
+     */
+    transform(expr: Expression): string {
+        switch (expr.$type) {
+            case LiteralExpr:
+                return this.literal(expr as LiteralExpr);
+
+            case ArrayExpr:
+                return this.array(expr as ArrayExpr);
+
+            case NullExpr:
+                return this.null();
+
+            case ThisExpr:
+                return this.this(expr as ThisExpr);
+
+            case ReferenceExpr:
+                return this.reference(expr as ReferenceExpr);
+
+            case InvocationExpr:
+                return this.invocation(expr as InvocationExpr);
+
+            case MemberAccessExpr:
+                return this.memberAccess(expr as MemberAccessExpr);
+
+            default:
+                throw new GeneratorError(
+                    `Unsupported expression type: ${expr.$type}`
+                );
+        }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    private this(expr: ThisExpr) {
+        // "this" is mapped to id comparison
+        return 'id';
+    }
+
+    private memberAccess(expr: MemberAccessExpr) {
+        if (!expr.member.ref) {
+            throw new GeneratorError(`Unresolved MemberAccessExpr`);
+        }
+
+        if (isThisExpr(expr.operand)) {
+            return expr.member.ref.name;
+        } else {
+            return `${this.transform(expr.operand)}?.${expr.member.ref.name}`;
+        }
+    }
+
+    private invocation(expr: InvocationExpr) {
+        if (expr.function.ref?.name !== 'auth') {
+            throw new GeneratorError(
+                `Function invocation is not supported: ${expr.function.ref?.name}`
+            );
+        }
+        return 'user';
+    }
+
+    private reference(expr: ReferenceExpr) {
+        if (!expr.target.ref) {
+            throw new GeneratorError(`Unresolved ReferenceExpr`);
+        }
+
+        if (isEnumField(expr.target.ref)) {
+            return `${expr.target.ref.$container.name}.${expr.target.ref.name}`;
+        } else {
+            return expr.target.ref.name;
+        }
+    }
+
+    private null() {
+        return 'null';
+    }
+
+    private array(expr: ArrayExpr) {
+        return `[${expr.items.map((item) => this.transform(item)).join(', ')}]`;
+    }
+
+    private literal(expr: LiteralExpr) {
+        if (typeof expr.value === 'string') {
+            return `'${expr.value}'`;
+        } else {
+            return expr.value.toString();
+        }
+    }
+}

package/src/generator/react-hooks/index.ts

@@ -0,0 +1,184 @@
+import { Context, Generator } from '../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import { paramCase } from 'change-case';
+import { DataModel } from '@lang/generated/ast';
+import colors from 'colors';
+import { extractDataModelsWithAllowRules } from '../utils';
+import { API_ROUTE_NAME, INTERNAL_PACKAGE } from '../constants';
+
+/**
+ * Generate react data query hooks code
+ */
+export default class ReactHooksGenerator implements Generator {
+    async generate(context: Context): Promise<void> {
+        const project = new Project();
+
+        const models = extractDataModelsWithAllowRules(context.schema);
+
+        this.generateIndex(project, context, models);
+
+        models.forEach((d) => this.generateModelHooks(project, context, d));
+
+        await project.save();
+
+        console.log(colors.blue('  ✔️ React hooks generated'));
+    }
+
+    private generateModelHooks(
+        project: Project,
+        context: Context,
+        model: DataModel
+    ) {
+        const fileName = paramCase(model.name);
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, `src/hooks/${fileName}.ts`),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addImportDeclaration({
+            namedImports: [{ name: 'Prisma', alias: 'P' }, model.name],
+            isTypeOnly: true,
+            moduleSpecifier: '../../.prisma',
+        });
+        sf.addStatements(`import { request } from '${INTERNAL_PACKAGE}';`);
+        sf.addStatements(`import { type SWRResponse } from 'swr'`);
+
+        sf.addStatements(
+            `const endpoint = '/api/${API_ROUTE_NAME}/data/${model.name}';`
+        );
+
+        const useFuncBody = sf
+            .addFunction({
+                name: `use${model.name}`,
+                isExported: true,
+            })
+            .addBody();
+
+        useFuncBody.addStatements(['const mutate = request.getMutate();']);
+
+        // create
+        useFuncBody
+            .addFunction({
+                name: 'create',
+                isAsync: true,
+                typeParameters: [`T extends P.${model.name}CreateArgs`],
+                parameters: [
+                    { name: 'args', type: `P.${model.name}CreateArgs` },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.post<P.${model.name}CreateArgs, P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(endpoint, args, mutate);`,
+            ]);
+
+        // find
+        useFuncBody
+            .addFunction({
+                name: 'find',
+                typeParameters: [`T extends P.${model.name}FindManyArgs`],
+                returnType: `SWRResponse<P.CheckSelect<T, ${model.name}[], P.${model.name}GetPayload<T, keyof T>[]>, any>`,
+                parameters: [
+                    {
+                        name: 'args?',
+                        type: `P.SelectSubset<T, P.${model.name}FindManyArgs>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.get<P.CheckSelect<T, Array<${model.name}>, Array<P.${model.name}GetPayload<T>>>>(endpoint, args);`,
+            ]);
+
+        // get
+        useFuncBody
+            .addFunction({
+                name: 'get',
+                typeParameters: [
+                    `T extends P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>`,
+                ],
+                returnType: `SWRResponse<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T, keyof T>>, any>`,
+                parameters: [
+                    {
+                        name: 'id',
+                        type: 'String',
+                    },
+                    {
+                        name: 'args?',
+                        type: `P.SelectSubset<T, P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.get<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(id ? \`\${endpoint}/\${id}\`: null, args);`,
+            ]);
+
+        // update
+        useFuncBody
+            .addFunction({
+                name: 'update',
+                isAsync: true,
+                typeParameters: [
+                    `T extends Omit<P.${model.name}UpdateArgs, 'where'>`,
+                ],
+                parameters: [
+                    { name: 'id', type: 'String' },
+                    {
+                        name: 'args',
+                        type: `Omit<P.${model.name}UpdateArgs, 'where'>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.put<Omit<P.${model.name}UpdateArgs, 'where'>, P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);`,
+            ]);
+
+        // del
+        useFuncBody
+            .addFunction({
+                name: 'del',
+                isAsync: true,
+                typeParameters: [
+                    `T extends Omit<P.${model.name}DeleteArgs, 'where'>`,
+                ],
+                parameters: [
+                    { name: 'id', type: 'String' },
+                    {
+                        name: 'args?',
+                        type: `Omit<P.${model.name}DeleteArgs, 'where'>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.del<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);`,
+            ]);
+
+        useFuncBody.addStatements([
+            'return { create, find, get, update, del };',
+        ]);
+
+        sf.formatText();
+    }
+
+    private generateIndex(
+        project: Project,
+        context: Context,
+        models: DataModel[]
+    ) {
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/hooks/index.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addStatements(
+            models.map((d) => `export * from './${paramCase(d.name)}';`)
+        );
+
+        sf.formatText();
+    }
+}

package/src/generator/service/index.ts

@@ -0,0 +1,110 @@
+import { Context, Generator } from '../types';
+import { Project, StructureKind, VariableDeclarationKind } from 'ts-morph';
+import * as path from 'path';
+import colors from 'colors';
+import { INTERNAL_PACKAGE } from '../constants';
+
+/**
+ * Generates ZenStack service code
+ */
+export default class ServiceGenerator implements Generator {
+    async generate(context: Context): Promise<void> {
+        const project = new Project();
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/index.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addImportDeclaration({
+            namedImports: ['PrismaClient'],
+            moduleSpecifier: '../.prisma',
+        });
+
+        sf.addImportDeclaration({
+            namedImports: ['Service', 'PolicyOperationKind', 'QueryContext'],
+            moduleSpecifier: INTERNAL_PACKAGE,
+            isTypeOnly: true,
+        });
+
+        const cls = sf.addClass({
+            name: 'ZenStackService',
+            isExported: true,
+            implements: ['Service<PrismaClient>'],
+        });
+        cls.addMember({
+            kind: StructureKind.Property,
+            name: 'private readonly _prisma',
+            initializer: 'new PrismaClient()',
+        });
+
+        cls.addGetAccessor({
+            name: 'db',
+        })
+            .addBody()
+            .setBodyText('return this._prisma;');
+
+        sf.addVariableStatement({
+            declarationKind: VariableDeclarationKind.Let,
+            declarations: [
+                {
+                    name: 'guardModule',
+                    type: 'any',
+                },
+            ],
+        });
+        cls
+            .addMethod({
+                name: 'resolveField',
+                isAsync: true,
+                parameters: [
+                    {
+                        name: 'model',
+                        type: 'string',
+                    },
+                    {
+                        name: 'field',
+                        type: 'string',
+                    },
+                ],
+            })
+            .addBody().setBodyText(`
+                if (!guardModule) {
+                    guardModule = await import('./query/guard');
+                }
+                return guardModule._fieldMapping?.[model]?.[field];
+            `);
+
+        cls
+            .addMethod({
+                name: 'buildQueryGuard',
+                isAsync: true,
+                parameters: [
+                    {
+                        name: 'model',
+                        type: 'string',
+                    },
+                    {
+                        name: 'operation',
+                        type: 'PolicyOperationKind',
+                    },
+                    {
+                        name: 'context',
+                        type: 'QueryContext',
+                    },
+                ],
+            })
+            .addBody().setBodyText(`
+                const module: any = await import('./query/guard');
+                const provider: (context: QueryContext) => any = module[model+ '_' + operation];
+                return provider(context);
+            `);
+
+        sf.addStatements(['export default new ZenStackService();']);
+
+        sf.formatText();
+        await project.save();
+
+        console.log(colors.blue(`  ✔️ ZenStack service generated`));
+    }
+}