zenstack 0.1.12 → 0.1.13

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

@@ -1,295 +0,0 @@
-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 } 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', '.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)
-                ),
-            ]),
-        ]);
-
-        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/src/generator/react-hooks/index.ts

@@ -1,265 +0,0 @@
-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';
-
-export default class ReactHooksGenerator implements Generator {
-    async generate(context: Context) {
-        const project = new Project();
-
-        const models = extractDataModelsWithAllowRules(context.schema);
-
-        this.generateIndex(project, context, models);
-        this.generateRequestRuntime(project, context);
-
-        models.forEach((d) => this.generateModelHooks(project, context, d));
-
-        await project.save();
-
-        console.log(colors.blue('  ✔️ React hooks generated'));
-    }
-
-    private generateRequestRuntime(project: Project, context: Context) {
-        const content = `
-        import useSWR, { useSWRConfig } from 'swr';
-        import type { ScopedMutator } from 'swr/dist/types';
-        
-        const fetcher = async (url: string, options?: RequestInit) => {
-            const res = await fetch(url, options);
-            if (!res.ok) {
-                const error: Error & { info?: any; status?: number } = new Error(
-                    'An error occurred while fetching the data.'
-                );
-                error.info = await res.json();
-                error.status = res.status;
-                throw error;
-            }
-            return res.json();
-        };
-        
-        function makeUrl(url: string, args: unknown) {
-            return args ? url + \`q=\${encodeURIComponent(JSON.stringify(args))}\` : url;
-        }
-        
-        export function get<Data, Error = any>(url: string, args?: unknown) {
-            return useSWR<Data, Error>(makeUrl(url, args), fetcher);
-        }
-        
-        export async function post<Data, Result>(
-            url: string,
-            data: Data,
-            mutate: ScopedMutator<any>
-        ) {
-            const r: Result = await fetcher(url, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                },
-                body: JSON.stringify(data),
-            });
-            mutate(url);
-            return r;
-        }
-        
-        export async function put<Data, Result>(
-            url: string,
-            data: Data,
-            mutate: ScopedMutator<any>
-        ) {
-            const r: Result = await fetcher(url, {
-                method: 'PUT',
-                headers: {
-                    'content-type': 'application/json',
-                },
-                body: JSON.stringify(data),
-            });
-            mutate(url, r);
-            return r;
-        }
-        
-        export async function del<Result>(
-            url: string,
-            args: unknown,
-            mutate: ScopedMutator<any>
-        ) {
-            const reqUrl = makeUrl(url, args);
-            const r: Result = await fetcher(reqUrl, {
-                method: 'DELETE',
-            });
-            const path = url.split('/');
-            path.pop();
-            mutate(path.join('/'));
-            return r;
-        }
-        
-        export function getMutate() {
-            const { mutate } = useSWRConfig();
-            return mutate;
-        }
-        `;
-
-        const sf = project.createSourceFile(
-            path.join(context.outDir, `hooks/request.ts`),
-            content,
-            { overwrite: true }
-        );
-        sf.formatText();
-    }
-
-    private generateModelHooks(
-        project: Project,
-        context: Context,
-        model: DataModel
-    ) {
-        const fileName = paramCase(model.name);
-        const sf = project.createSourceFile(
-            path.join(context.outDir, `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 './request';`]);
-
-        sf.addStatements(`const endpoint = '/api/zen/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`],
-                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',
-                isAsync: true,
-                typeParameters: [
-                    `T extends P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>`,
-                ],
-                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>>>(\`\${endpoint}/\${id}\`, 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.outDir, 'hooks/index.ts'),
-            undefined,
-            { overwrite: true }
-        );
-
-        sf.addStatements(
-            models.map((d) => `export * from './${paramCase(d.name)}';`)
-        );
-
-        sf.formatText();
-    }
-}

package/src/generator/service/index.ts

@@ -1,96 +0,0 @@
-import { Context, Generator } from '../types';
-import { Project, StructureKind } from 'ts-morph';
-import * as path from 'path';
-import colors from 'colors';
-import { RUNTIME_PACKAGE } from '../constants';
-
-export default class ServiceGenerator implements Generator {
-    async generate(context: Context) {
-        const project = new Project();
-        const sf = project.createSourceFile(
-            path.join(context.outDir, 'index.ts'),
-            undefined,
-            { overwrite: true }
-        );
-
-        sf.addImportDeclaration({
-            namedImports: ['PrismaClient'],
-            moduleSpecifier: './.prisma',
-        });
-
-        sf.addImportDeclaration({
-            namedImports: ['Service', 'PolicyOperationKind', 'QueryContext'],
-            moduleSpecifier: RUNTIME_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;');
-
-        cls
-            .addMethod({
-                name: 'resolveField',
-                isAsync: true,
-                parameters: [
-                    {
-                        name: 'model',
-                        type: 'string',
-                    },
-                    {
-                        name: 'field',
-                        type: 'string',
-                    },
-                ],
-            })
-            .addBody().setBodyText(`
-                const module: any = await import('./query/guard');
-                return module._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/src/generator/tsconfig.template.json

@@ -1,17 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES6",
-        "module": "CommonJS",
-        "lib": ["ESNext", "DOM"],
-        "sourceMap": true,
-        "outDir": ".",
-        "strict": true,
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "declaration": true,
-        "resolveJsonModule": true
-    },
-    "include": ["**/*.ts"],
-    "exclude": ["node_modules", ".prisma", "**/*.d.ts"]
-}

package/src/generator/types.ts

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

package/src/generator/utils.ts

@@ -1,9 +0,0 @@
-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[];
-}