zenstack 0.5.0 → 0.6.0-pre.1

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

@@ -1,370 +0,0 @@
-import indentString from '../../utils/indent-string';
-
-/**
- * Prisma schema builder
- */
-export class PrismaModel {
-    private datasources: DataSource[] = [];
-    private generators: Generator[] = [];
-    private models: Model[] = [];
-    private enums: Enum[] = [];
-
-    addDataSource(
-        name: string,
-        provider: string,
-        url: DataSourceUrl,
-        shadowDatabaseUrl?: DataSourceUrl
-    ): DataSource {
-        const ds = new DataSource(name, provider, url, shadowDatabaseUrl);
-        this.datasources.push(ds);
-        return ds;
-    }
-
-    addGenerator(
-        name: string,
-        provider: string,
-        output: string,
-        previewFeatures?: string[]
-    ): Generator {
-        const generator = new Generator(
-            name,
-            provider,
-            output,
-            previewFeatures
-        );
-        this.generators.push(generator);
-        return generator;
-    }
-
-    addModel(name: string): Model {
-        const model = new Model(name);
-        this.models.push(model);
-        return model;
-    }
-
-    addEnum(name: string, fields: string[]): Enum {
-        const e = new Enum(name, fields);
-        this.enums.push(e);
-        return e;
-    }
-
-    toString(): string {
-        return [
-            ...this.datasources,
-            ...this.generators,
-            ...this.enums,
-            ...this.models,
-        ]
-            .map((d) => d.toString())
-            .join('\n\n');
-    }
-}
-
-export class DataSource {
-    constructor(
-        public name: string,
-        public provider: string,
-        public url: DataSourceUrl,
-        public shadowDatabaseUrl?: DataSourceUrl
-    ) {}
-
-    toString(): string {
-        return (
-            `datasource ${this.name} {\n` +
-            indentString(`provider="${this.provider}"\n`) +
-            indentString(`url=${this.url}\n`) +
-            (this.shadowDatabaseUrl
-                ? indentString(`shadowDatabaseurl=${this.shadowDatabaseUrl}\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 provider: string,
-        public output: string,
-        public previewFeatures?: string[]
-    ) {}
-
-    toString(): string {
-        return (
-            `generator ${this.name} {\n` +
-            indentString(`provider = "${this.provider}"\n`) +
-            indentString(`output = ${JSON.stringify(this.output)}\n`) +
-            (this.previewFeatures
-                ? indentString(
-                      `previewFeatures = [${this.previewFeatures
-                          ?.map((f) => '"' + f + '"')
-                          .join(', ')}]\n`
-                  )
-                : '') +
-            `}`
-        );
-    }
-}
-
-export class Model {
-    public fields: ModelField[] = [];
-    public attributes: ModelAttribute[] = [];
-    constructor(public name: string) {}
-
-    addField(
-        name: string,
-        type: ModelFieldType | string,
-        attributes: FieldAttribute[] = []
-    ): ModelField {
-        const field = new ModelField(name, type, attributes);
-        this.fields.push(field);
-        return field;
-    }
-
-    addAttribute(name: string, args: AttributeArg[] = []): ModelAttribute {
-        const attr = new ModelAttribute(name, args);
-        this.attributes.push(attr);
-        return attr;
-    }
-
-    toString(): string {
-        return (
-            `model ${this.name} {\n` +
-            indentString(
-                [...this.fields, ...this.attributes]
-                    .map((d) => d.toString())
-                    .join('\n')
-            ) +
-            `\n}`
-        );
-    }
-}
-
-export type ScalarTypes =
-    | 'String'
-    | 'Boolean'
-    | 'Int'
-    | 'BigInt'
-    | 'Float'
-    | 'Decimal'
-    | 'DateTime'
-    | 'Json'
-    | 'Bytes'
-    | 'Unsupported';
-
-export class ModelFieldType {
-    constructor(
-        public type: ScalarTypes | string,
-        public array?: boolean,
-        public optional?: boolean
-    ) {}
-
-    toString(): string {
-        return `${this.type}${this.array ? '[]' : ''}${
-            this.optional ? '?' : ''
-        }`;
-    }
-}
-
-export class ModelField {
-    constructor(
-        public name: string,
-        public type: ModelFieldType | string,
-        public attributes: FieldAttribute[] = []
-    ) {}
-
-    addAttribute(name: string, args: AttributeArg[] = []): FieldAttribute {
-        const attr = new FieldAttribute(name, args);
-        this.attributes.push(attr);
-        return attr;
-    }
-
-    toString(): string {
-        return (
-            `${this.name} ${this.type}` +
-            (this.attributes.length > 0
-                ? ' ' + this.attributes.map((a) => a.toString()).join(' ')
-                : '')
-        );
-    }
-}
-
-export class FieldAttribute {
-    constructor(public name: string, public args: AttributeArg[] = []) {}
-
-    toString(): string {
-        return (
-            `${this.name}(` +
-            this.args.map((a) => a.toString()).join(', ') +
-            `)`
-        );
-    }
-}
-
-export class ModelAttribute {
-    constructor(public name: string, public args: AttributeArg[] = []) {}
-
-    toString(): string {
-        return (
-            `${this.name}(` +
-            this.args.map((a) => a.toString()).join(', ') +
-            `)`
-        );
-    }
-}
-
-export class AttributeArg {
-    constructor(
-        public name: string | undefined,
-        public value: AttributeArgValue
-    ) {}
-
-    toString(): string {
-        return this.name
-            ? `${this.name}: ${this.value}`
-            : this.value.toString();
-    }
-}
-
-export class AttributeArgValue {
-    constructor(
-        public type:
-            | 'String'
-            | 'FieldReference'
-            | 'Number'
-            | 'Boolean'
-            | 'Array'
-            | 'FunctionCall',
-        public value:
-            | string
-            | number
-            | boolean
-            | FieldReference
-            | FunctionCall
-            | AttributeArgValue[]
-    ) {
-        switch (type) {
-            case 'String':
-                if (typeof value !== 'string')
-                    throw new Error('Value must be string');
-                break;
-            case 'Number':
-                if (typeof value !== 'number')
-                    throw new Error('Value must be number');
-                break;
-            case 'Boolean':
-                if (typeof value !== 'boolean')
-                    throw new Error('Value must be boolean');
-                break;
-            case 'Array':
-                if (!Array.isArray(value))
-                    throw new Error('Value must be array');
-                break;
-            case 'FieldReference':
-                if (
-                    typeof value !== 'string' &&
-                    !(value instanceof FieldReference)
-                )
-                    throw new Error('Value must be string or FieldReference');
-                break;
-            case 'FunctionCall':
-                if (!(value instanceof FunctionCall))
-                    throw new Error('Value must be FunctionCall');
-                break;
-        }
-    }
-
-    toString(): string {
-        switch (this.type) {
-            case 'String':
-                return `"${this.value}"`;
-            case 'Number':
-                return this.value.toString();
-            case 'FieldReference': {
-                if (typeof this.value === 'string') {
-                    return this.value;
-                } else {
-                    const fr = this.value as FieldReference;
-                    let r = fr.field;
-                    if (fr.args.length > 0) {
-                        r +=
-                            '(' +
-                            fr.args.map((a) => a.toString()).join(',') +
-                            ')';
-                    }
-                    return r;
-                }
-            }
-            case 'FunctionCall':
-                return this.value.toString();
-            case 'Boolean':
-                return this.value ? 'true' : 'false';
-            case 'Array':
-                return (
-                    '[' +
-                    (this.value as AttributeArgValue[])
-                        .map((v) => v.toString())
-                        .join(', ') +
-                    ']'
-                );
-            default:
-                throw new Error(`Unknown attribute value type ${this.type}`);
-        }
-    }
-}
-
-export class FieldReference {
-    constructor(public field: string, public args: FieldReferenceArg[] = []) {}
-}
-
-export class FieldReferenceArg {
-    constructor(public name: 'sort', public value: 'Asc' | 'Desc') {}
-
-    toString(): string {
-        return `${this.name}: ${this.value}`;
-    }
-}
-
-export class FunctionCall {
-    constructor(public func: string, public args: FunctionCallArg[] = []) {}
-
-    toString(): string {
-        return (
-            `${this.func}` +
-            '(' +
-            this.args.map((a) => a.toString()).join(', ') +
-            ')'
-        );
-    }
-}
-
-export class FunctionCallArg {
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-    constructor(public name: string | undefined, public value: any) {}
-
-    toString(): string {
-        return this.name ? `${this.name}: ${this.value}` : this.value;
-    }
-}
-
-export class Enum {
-    constructor(public name: string, public fields: EnumField[]) {}
-
-    toString(): string {
-        return (
-            `enum ${this.name} {\n` +
-            indentString(this.fields.join('\n')) +
-            '\n}'
-        );
-    }
-}
-
-type EnumField = string;

package/src/generator/prisma/query-guard-generator.ts

@@ -1,249 +0,0 @@
-import {
-    DataModel,
-    DataModelField,
-    isDataModel,
-    isEnum,
-    isLiteralExpr,
-} from '@lang/generated/ast';
-import {
-    FieldInfo,
-    PolicyKind,
-    PolicyOperationKind,
-    RuntimeAttribute,
-} from '@zenstackhq/runtime/server';
-import path from 'path';
-import { Project, SourceFile, VariableDeclarationKind } from 'ts-morph';
-import {
-    GUARD_FIELD_NAME,
-    RUNTIME_PACKAGE,
-    UNKNOWN_USER_ID,
-} from '../constants';
-import { Context } from '../types';
-import { resolved } from '../ast-utils';
-import ExpressionWriter from './expression-writer';
-
-/**
- * Generates source file that contains Prisma query guard objects used for injecting database queries
- */
-export default class QueryGuardGenerator {
-    constructor(private readonly context: Context) {}
-
-    async generate(): Promise<void> {
-        const project = new Project();
-        const sf = project.createSourceFile(
-            path.join(this.context.generatedCodeDir, 'src/query/guard.ts'),
-            undefined,
-            { overwrite: true }
-        );
-
-        sf.addImportDeclaration({
-            namedImports: [{ name: 'QueryContext' }],
-            moduleSpecifier: `${RUNTIME_PACKAGE}/server`,
-            isTypeOnly: true,
-        });
-
-        // import enums
-        for (const e of this.context.schema.declarations.filter((d) =>
-            isEnum(d)
-        )) {
-            sf.addImportDeclaration({
-                namedImports: [{ name: e.name }],
-                moduleSpecifier: '../../.prisma',
-            });
-        }
-
-        const models = this.context.schema.declarations.filter((d) =>
-            isDataModel(d)
-        ) as DataModel[];
-
-        this.generateFieldMapping(models, sf);
-
-        for (const model of models) {
-            await this.generateQueryGuardForModel(model, sf);
-        }
-
-        sf.formatText({});
-        await project.save();
-    }
-
-    private generateFieldMapping(models: DataModel[], sourceFile: SourceFile) {
-        const mapping = Object.fromEntries(
-            models.map((m) => [
-                m.name,
-                Object.fromEntries(
-                    m.fields.map((f) => {
-                        const fieldInfo: FieldInfo = {
-                            name: f.name,
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            type: f.type.reference
-                                ? f.type.reference.$refText
-                                : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                  f.type.type!,
-                            isDataModel: isDataModel(f.type.reference?.ref),
-                            isArray: f.type.array,
-                            isOptional: f.type.optional,
-                            attributes: this.getFieldAttributes(f),
-                        };
-                        return [f.name, fieldInfo];
-                    })
-                ),
-            ])
-        );
-
-        sourceFile.addVariableStatement({
-            isExported: true,
-            declarationKind: VariableDeclarationKind.Const,
-            declarations: [
-                {
-                    name: '_fieldMapping',
-                    initializer: JSON.stringify(mapping),
-                },
-            ],
-        });
-    }
-
-    private getFieldAttributes(field: DataModelField): RuntimeAttribute[] {
-        return field.attributes
-            .map((attr) => {
-                const args: Array<{ name?: string; value: unknown }> = [];
-                for (const arg of attr.args) {
-                    if (!isLiteralExpr(arg.value)) {
-                        // attributes with non-literal args are skipped
-                        return undefined;
-                    }
-                    args.push({ name: arg.name, value: arg.value.value });
-                }
-                return { name: resolved(attr.decl).name, args };
-            })
-            .filter((d): d is RuntimeAttribute => !!d);
-    }
-
-    private getPolicyExpressions(
-        model: DataModel,
-        kind: PolicyKind,
-        operation: PolicyOperationKind
-    ) {
-        const attrs = model.attributes.filter(
-            (attr) => attr.decl.ref?.name === `@@${kind}`
-        );
-        return attrs
-            .filter((attr) => {
-                if (
-                    !isLiteralExpr(attr.args[0].value) ||
-                    typeof attr.args[0].value.value !== 'string'
-                ) {
-                    return false;
-                }
-                const ops = attr.args[0].value.value
-                    .split(',')
-                    .map((s) => s.trim());
-                return ops.includes(operation) || ops.includes('all');
-            })
-            .map((attr) => attr.args[1].value);
-    }
-
-    private async generateQueryGuardForModel(
-        model: DataModel,
-        sourceFile: SourceFile
-    ) {
-        for (const kind of ['create', 'update', 'read', 'delete']) {
-            const func = sourceFile
-                .addFunction({
-                    name: model.name + '_' + kind,
-                    returnType: 'any',
-                    parameters: [
-                        {
-                            name: 'context',
-                            type: 'QueryContext',
-                        },
-                    ],
-                    isExported: true,
-                })
-                .addBody();
-
-            func.addStatements(
-                // make suer user id is always available
-                `const user = context.user?.id ? context.user : { ...context.user, id: '${UNKNOWN_USER_ID}' };`
-            );
-
-            // r = <guard object>;
-            func.addVariableStatement({
-                declarationKind: VariableDeclarationKind.Const,
-                declarations: [
-                    {
-                        name: 'r',
-                        initializer: (writer) => {
-                            const exprWriter = new ExpressionWriter(writer);
-                            const denies = this.getPolicyExpressions(
-                                model,
-                                'deny',
-                                kind as PolicyOperationKind
-                            );
-                            const allows = this.getPolicyExpressions(
-                                model,
-                                'allow',
-                                kind as PolicyOperationKind
-                            );
-
-                            const writeDenies = () => {
-                                writer.conditionalWrite(
-                                    denies.length > 1,
-                                    '{ AND: ['
-                                );
-                                denies.forEach((expr, i) => {
-                                    writer.block(() => {
-                                        writer.write('NOT: ');
-                                        exprWriter.write(expr);
-                                    });
-                                    writer.conditionalWrite(
-                                        i !== denies.length - 1,
-                                        ','
-                                    );
-                                });
-                                writer.conditionalWrite(
-                                    denies.length > 1,
-                                    ']}'
-                                );
-                            };
-
-                            const writeAllows = () => {
-                                writer.conditionalWrite(
-                                    allows.length > 1,
-                                    '{ OR: ['
-                                );
-                                allows.forEach((expr, i) => {
-                                    exprWriter.write(expr);
-                                    writer.conditionalWrite(
-                                        i !== allows.length - 1,
-                                        ','
-                                    );
-                                });
-                                writer.conditionalWrite(
-                                    allows.length > 1,
-                                    ']}'
-                                );
-                            };
-
-                            if (allows.length > 0 && denies.length > 0) {
-                                writer.writeLine('{ AND: [');
-                                writeDenies();
-                                writer.writeLine(',');
-                                writeAllows();
-                                writer.writeLine(']}');
-                            } else if (denies.length > 0) {
-                                writeDenies();
-                            } else if (allows.length > 0) {
-                                writeAllows();
-                            } else {
-                                // disallow any operation
-                                writer.write(`{ ${GUARD_FIELD_NAME}: false }`);
-                            }
-                        },
-                    },
-                ],
-            });
-
-            func.addStatements('return r;');
-        }
-    }
-}