zenstack 0.4.2 → 0.6.0-pre.1

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

@@ -1,313 +0,0 @@
-import {
-    Attribute,
-    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 '../ast-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';
-
-/**
- * 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']
-        );
-    }
-
-    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?');
-
-        // create an index for "zenstack_transaction" field
-        model.addAttribute('@@index', [
-            new PrismaAttributeArg(
-                undefined,
-                new PrismaAttributeArgValue('Array', [
-                    new PrismaAttributeArgValue(
-                        'FieldReference',
-                        TRANSACTION_FIELD_NAME
-                    ),
-                ])
-            ),
-        ]);
-
-        for (const attr of decl.attributes.filter(
-            (attr) => attr.decl.ref && this.isPrismaAttribute(attr.decl.ref)
-        )) {
-            this.generateModelAttribute(model, attr);
-        }
-    }
-
-    private isPrismaAttribute(attr: Attribute) {
-        return !!attr.attributes.find((a) => a.decl.ref?.name === '@@@prisma');
-    }
-
-    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 && this.isPrismaAttribute(attr.decl.ref)
-            )
-            .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

@@ -1,108 +0,0 @@
-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

@@ -1,273 +0,0 @@
-import { DataModel, isDataModel } from '@lang/generated/ast';
-import { paramCase } from 'change-case';
-import * as path from 'path';
-import { Project } from 'ts-morph';
-import { API_ROUTE_NAME, RUNTIME_PACKAGE } from '../constants';
-import { Context, Generator } from '../types';
-
-/**
- * Generate react data query hooks code
- */
-export default class ReactHooksGenerator implements Generator {
-    get name() {
-        return 'react-hooks';
-    }
-
-    get startMessage() {
-        return 'Generating React hooks...';
-    }
-
-    get successMessage(): string {
-        return 'Successfully generated React hooks';
-    }
-
-    async generate(context: Context) {
-        const project = new Project();
-        const models: DataModel[] = [];
-        const warnings: string[] = [];
-
-        for (const model of context.schema.declarations.filter(
-            (d): d is DataModel => isDataModel(d)
-        )) {
-            const hasAllowRule = model.attributes.find(
-                (attr) => attr.decl.ref?.name === '@@allow'
-            );
-            if (!hasAllowRule) {
-                warnings.push(
-                    `Not generating hooks for "${model.name}" because it doesn't have any @@allow rule`
-                );
-            } else {
-                models.push(model);
-            }
-        }
-
-        this.generateIndex(project, context, models);
-
-        models.forEach((d) => this.generateModelHooks(project, context, d));
-
-        await project.save();
-        return warnings;
-    }
-
-    private getValidator(model: DataModel, mode: 'create' | 'update') {
-        return `${model.name}_${mode}_validator`;
-    }
-
-    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 * as request from '${RUNTIME_PACKAGE}/lib/request';`,
-            `import { ServerErrorCode, RequestOptions } from '${RUNTIME_PACKAGE}/lib/types';`,
-            `import { validate } from '${RUNTIME_PACKAGE}/lib/validation';`,
-            `import { type SWRResponse } from 'swr';`,
-            `import { ${this.getValidator(
-                model,
-                'create'
-            )}, ${this.getValidator(
-                model,
-                'update'
-            )} } from '../field-constraint';`,
-        ]);
-
-        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([
-                `
-                // validate field-level constraints
-                validate(${this.getValidator(model, 'create')}, args.data);
-
-                try {
-                    return await request.post<P.${
-                        model.name
-                    }CreateArgs, P.CheckSelect<T, ${model.name}, P.${
-                    model.name
-                }GetPayload<T>>>(endpoint, args, mutate);
-                } catch (err: any) {
-                    if (err.info?.code === ServerErrorCode.READ_BACK_AFTER_WRITE_DENIED) {
-                        return undefined;
-                    } else {
-                        throw err;
-                    }
-                }
-                `,
-            ]);
-
-        // find
-        useFuncBody
-            .addFunction({
-                name: 'find',
-                typeParameters: [`T extends P.${model.name}FindManyArgs`],
-                returnType: `SWRResponse<P.CheckSelect<T, ${model.name}[], P.${model.name}GetPayload<T>[]>, any>`,
-                parameters: [
-                    {
-                        name: 'args?',
-                        type: `P.SelectSubset<T, P.${model.name}FindManyArgs>`,
-                    },
-                    {
-                        name: 'options?',
-                        type: `RequestOptions<P.CheckSelect<T, Array<${model.name}>, Array<P.${model.name}GetPayload<T>>>>`,
-                    },
-                ],
-            })
-            .addBody()
-            .addStatements([
-                `return request.get<P.CheckSelect<T, Array<${model.name}>, Array<P.${model.name}GetPayload<T>>>>(endpoint, args, options);`,
-            ]);
-
-        // get
-        useFuncBody
-            .addFunction({
-                name: 'get',
-                typeParameters: [`T extends P.${model.name}FindFirstArgs`],
-                returnType: `SWRResponse<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>, any>`,
-                parameters: [
-                    {
-                        name: 'id',
-                        type: 'String | undefined',
-                    },
-                    {
-                        name: 'args?',
-                        type: `P.SelectSubset<T, P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>>`,
-                    },
-                    {
-                        name: 'options?',
-                        type: `RequestOptions<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>`,
-                    },
-                ],
-            })
-            .addBody()
-            .addStatements([
-                `return request.get<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(id ? \`\${endpoint}/\${id}\`: null, args, options);`,
-            ]);
-
-        // 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([
-                `
-                // validate field-level constraints
-                validate(${this.getValidator(model, 'update')}, args.data);
-                
-                try {
-                    return await request.put<Omit<P.${
-                        model.name
-                    }UpdateArgs, 'where'>, P.CheckSelect<T, ${model.name}, P.${
-                    model.name
-                }GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);
-                } catch (err: any) {
-                    if (err.info?.code === ServerErrorCode.READ_BACK_AFTER_WRITE_DENIED) {
-                        return undefined;
-                    } else {
-                        throw err;
-                    }
-                }
-                `,
-            ]);
-
-        // 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([
-                `
-                try {
-                    return await request.del<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);
-                } catch (err: any) {
-                    if (err.info?.code === ServerErrorCode.READ_BACK_AFTER_WRITE_DENIED) {
-                        return undefined;
-                    } else {
-                        throw err;
-                    }
-                }
-                `,
-            ]);
-
-        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();
-    }
-}