zenstack 0.1.42 → 1.0.0

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

@@ -0,0 +1,366 @@
+import indentString from '../../utils/indent-string';
+
+export class PrismaModel {
+    private datasources: DataSource[] = [];
+    private generators: Generator[] = [];
+    private models: Model[] = [];
+    private enums: Enum[] = [];
+
+    addDataSource(
+        name: string,
+        provider: string,
+        url: DataSourceUrl,
+        shadowDatabaseUrl?: DataSourceUrl
+    ) {
+        const ds = new DataSource(name, provider, url, shadowDatabaseUrl);
+        this.datasources.push(ds);
+        return ds;
+    }
+
+    addGenerator(
+        name: string,
+        provider: string,
+        output: string,
+        previewFeatures?: string[]
+    ) {
+        const generator = new Generator(
+            name,
+            provider,
+            output,
+            previewFeatures
+        );
+        this.generators.push(generator);
+        return generator;
+    }
+
+    addModel(name: string) {
+        const model = new Model(name);
+        this.models.push(model);
+        return model;
+    }
+
+    addEnum(name: string, fields: string[]) {
+        const e = new Enum(name, fields);
+        this.enums.push(e);
+        return e;
+    }
+
+    toString() {
+        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() {
+        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() {
+        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() {
+        return (
+            `generator ${this.name} {\n` +
+            indentString(`provider = "${this.provider}"\n`) +
+            indentString(`output = "${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[] = []
+    ) {
+        const field = new ModelField(name, type, attributes);
+        this.fields.push(field);
+        return field;
+    }
+
+    addAttribute(name: string, args: AttributeArg[] = []) {
+        const attr = new ModelAttribute(name, args);
+        this.attributes.push(attr);
+        return attr;
+    }
+
+    toString() {
+        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() {
+        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[] = []) {
+        const attr = new FieldAttribute(name, args);
+        this.attributes.push(attr);
+        return attr;
+    }
+
+    toString() {
+        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() {
+        return (
+            `@${this.name}(` +
+            this.args.map((a) => a.toString()).join(', ') +
+            `)`
+        );
+    }
+}
+
+export class ModelAttribute {
+    constructor(public name: string, public args: AttributeArg[] = []) {}
+
+    toString() {
+        return (
+            `@@${this.name}(` +
+            this.args.map((a) => a.toString()).join(', ') +
+            `)`
+        );
+    }
+}
+
+export class AttributeArg {
+    constructor(
+        public name: string | undefined,
+        public value: AttributeArgValue
+    ) {}
+
+    toString() {
+        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() {
+        return `${this.name}: ${this.value}`;
+    }
+}
+
+export class FunctionCall {
+    constructor(public func: string, public args: FunctionCallArg[] = []) {}
+
+    toString() {
+        return (
+            `${this.func}` +
+            '(' +
+            this.args.map((a) => a.toString()).join(', ') +
+            ')'
+        );
+    }
+}
+
+export class FunctionCallArg {
+    constructor(public name: string | undefined, public value: any) {}
+
+    toString() {
+        return this.name ? `${this.name}: ${this.value}` : this.value;
+    }
+}
+
+export class Enum {
+    constructor(public name: string, public fields: EnumField[]) {}
+
+    toString() {
+        return (
+            `enum ${this.name} {\n` +
+            indentString(this.fields.join('\n')) +
+            '\n}'
+        );
+    }
+}
+
+type EnumField = String;

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

@@ -0,0 +1,208 @@
+import {
+    DataModel,
+    isDataModel,
+    isEnum,
+    isLiteralExpr,
+} from '@lang/generated/ast';
+import { PolicyKind, PolicyOperationKind } from '@zenstackhq/internal';
+import path from 'path';
+import { Project, SourceFile, VariableDeclarationKind } from 'ts-morph';
+import { GUARD_FIELD_NAME, INTERNAL_PACKAGE } from '../constants';
+import { Context } from '../types';
+import ExpressionWriter from './expression-writer';
+
+export default class QueryGuardGenerator {
+    constructor(private readonly context: Context) {}
+
+    async generate() {
+        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: INTERNAL_PACKAGE,
+            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);
+
+        models.forEach((model) => 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
+                        .filter((f) => isDataModel(f.type.reference?.ref))
+                        .map((f) => [
+                            f.name,
+                            {
+                                type: f.type.reference!.ref!.name,
+                                isArray: f.type.array,
+                            },
+                        ])
+                ),
+            ])
+        );
+
+        sourceFile.addVariableStatement({
+            isExported: true,
+            declarationKind: VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: '_fieldMapping',
+                    initializer: JSON.stringify(mapping),
+                },
+            ],
+        });
+    }
+
+    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('const { user } = context;');
+
+            // 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;');
+        }
+    }
+}