zenstack 0.1.41 → 1.0.0

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

@@ -0,0 +1,300 @@
+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 {
+    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 supportedProviders = ['postgresql', 'mysql', 'sqlite', 'sqlserver'];
+const supportedAttrbutes = [
+    'id',
+    'index',
+    'relation',
+    'default',
+    'createdAt',
+    'updatedAt',
+    'unique',
+];
+
+export default class PrismaSchemaGenerator {
+    constructor(private readonly context: Context) {}
+
+    async generate() {
+        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'
+                        );
+                    }
+                    if (!supportedProviders.includes(provider)) {
+                        throw new GeneratorError(
+                            `Provider ${provider} is not supported. Supported providers: ${supportedProviders.join(
+                                ', '
+                            )}`
+                        );
+                    }
+                    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']
+        );
+    }
+
+    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) =>
+            supportedAttrbutes.includes(attr.decl.ref?.name!)
+        )) {
+            this.generateModelAttribute(model, attr);
+        }
+    }
+
+    private generateModelField(model: PrismaDataModel, field: DataModelField) {
+        const type = new ModelFieldType(
+            (field.type.type || field.type.reference?.ref?.name)!,
+            field.type.array,
+            field.type.optional
+        );
+
+        const attributes = field.attributes
+            .filter((attr) => supportedAttrbutes.includes(attr.decl.ref?.name!))
+            .map((attr) => this.makeFieldAttribute(attr));
+        model.addField(field.name, type, attributes);
+    }
+
+    private makeFieldAttribute(attr: DataModelFieldAttribute) {
+        return new PrismaFieldAttribute(
+            attr.decl.ref?.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(
+                    node.target.ref?.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(
+            node.function.ref?.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(
+                attr.decl.ref?.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/packages/schema/src/generator/react-hooks/index.ts

@@ -0,0 +1,181 @@
+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';
+
+export default class ReactHooksGenerator implements Generator {
+    async generate(context: Context) {
+        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/packages/schema/src/generator/service/index.ts

@@ -0,0 +1,107 @@
+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';
+
+export default class ServiceGenerator implements Generator {
+    async generate(context: Context) {
+        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`));
+    }
+}

package/packages/schema/src/generator/types.ts

@@ -0,0 +1,17 @@
+import { Model } from '@lang/generated/ast';
+
+export interface Context {
+    schema: Model;
+    outDir: string;
+    generatedCodeDir: string;
+}
+
+export interface Generator {
+    generate(context: Context): Promise<void>;
+}
+
+export class GeneratorError extends Error {
+    constructor(message: string) {
+        super(message);
+    }
+}

package/packages/schema/src/generator/utils.ts

@@ -0,0 +1,9 @@
+import { DataModel, isDataModel, Model } from '@lang/generated/ast';
+
+export function extractDataModelsWithAllowRules(model: Model) {
+    return model.declarations.filter(
+        (d) =>
+            isDataModel(d) &&
+            !!d.attributes.find((attr) => attr.decl.ref?.name === 'allow')
+    ) as DataModel[];
+}