zenstack 0.4.2 → 0.6.0-pre.1

package/src/cli/index.ts

@@ -1,246 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { paramCase } from 'change-case';
-import colors from 'colors';
-import { Command, Option } from 'commander';
-import path from 'path';
-import { PackageManagers } from '../utils/pkg-utils';
-import { ZModelLanguageMetaData } from '../language-server/generated/module';
-import telemetry from '../telemetry';
-import { execSync } from '../utils/exec-utils';
-import { CliError } from './cli-error';
-import { initProject, runGenerator } from './cli-util';
-
-export const initAction = async (
-    projectPath: string,
-    options: {
-        packageManager: PackageManagers | undefined;
-    }
-): Promise<void> => {
-    await telemetry.trackSpan(
-        'cli:command:start',
-        'cli:command:complete',
-        'cli:command:error',
-        { command: 'init' },
-        () => initProject(projectPath, options.packageManager)
-    );
-};
-
-export const generateAction = async (options: {
-    schema: string;
-    packageManager: PackageManagers | undefined;
-}): Promise<void> => {
-    await telemetry.trackSpan(
-        'cli:command:start',
-        'cli:command:complete',
-        'cli:command:error',
-        { command: 'generate' },
-        () => runGenerator(options)
-    );
-};
-
-function prismaAction(prismaCmd: string): (...args: any[]) => Promise<void> {
-    return async (options: any, command: Command) => {
-        await telemetry.trackSpan(
-            'cli:command:start',
-            'cli:command:complete',
-            'cli:command:error',
-            {
-                command: prismaCmd
-                    ? prismaCmd + ' ' + command.name()
-                    : command.name(),
-            },
-            async () => {
-                const optStr = Array.from(Object.entries<any>(options))
-                    .map(([k, v]) => {
-                        let optVal = v;
-                        if (k === 'schema') {
-                            optVal = path.join(
-                                path.dirname(v),
-                                'schema.prisma'
-                            );
-                        }
-                        return (
-                            '--' +
-                            paramCase(k) +
-                            (typeof optVal === 'string' ? ` ${optVal}` : '')
-                        );
-                    })
-                    .join(' ');
-
-                // regenerate prisma schema first
-                await runGenerator(options, ['prisma'], false);
-
-                const prismaExec = `npx prisma ${prismaCmd} ${command.name()} ${optStr}`;
-                console.log(prismaExec);
-                try {
-                    execSync(prismaExec);
-                } catch {
-                    telemetry.track('cli:command:error', {
-                        command: prismaCmd,
-                    });
-                    console.error(
-                        colors.red(
-                            'Prisma command failed to execute. See errors above.'
-                        )
-                    );
-                    throw new CliError('prisma command run error');
-                }
-            }
-        );
-    };
-}
-
-export default async function (): Promise<void> {
-    await telemetry.trackSpan(
-        'cli:start',
-        'cli:complete',
-        'cli:error',
-        { args: process.argv },
-        async () => {
-            const program = new Command('zenstack');
-
-            program.version(
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                require('../../package.json').version,
-                '-v --version',
-                'display CLI version'
-            );
-
-            const schemaExtensions =
-                ZModelLanguageMetaData.fileExtensions.join(', ');
-
-            program
-                .description(
-                    `${colors.bold.blue(
-                        'ζ'
-                    )} ZenStack is a toolkit for building secure CRUD apps with Next.js + Typescript.\n\nDocumentation: https://zenstack.dev.`
-                )
-                .showHelpAfterError()
-                .showSuggestionAfterError();
-
-            const schemaOption = new Option(
-                '--schema <file>',
-                `schema file (with extension ${schemaExtensions})`
-            ).default('./zenstack/schema.zmodel');
-
-            const pmOption = new Option(
-                '-p, --package-manager <pm>',
-                'package manager to use'
-            ).choices(['npm', 'yarn', 'pnpm']);
-
-            //#region wraps Prisma commands
-
-            program
-                .command('init')
-                .description('Set up a new ZenStack project.')
-                .addOption(pmOption)
-                .argument('[path]', 'project path', '.')
-                .action(initAction);
-
-            program
-                .command('generate')
-                .description(
-                    'Generates RESTful API and Typescript client for your data model.'
-                )
-                .addOption(schemaOption)
-                .addOption(pmOption)
-                .action(generateAction);
-
-            const migrate = program
-                .command('migrate')
-                .description(
-                    `Updates the database schema with migrations\nAlias for ${colors.cyan(
-                        'prisma migrate'
-                    )}.`
-                );
-
-            migrate
-                .command('dev')
-                .description(
-                    `Creates a migration, apply it to the database, generate db client\nAlias for ${colors.cyan(
-                        'prisma migrate dev'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .option(
-                    '--create-only',
-                    'Create a migration without applying it'
-                )
-                .option('-n --name <name>', 'Name the migration')
-                .option('--skip-seed', 'Skip triggering seed')
-                .action(prismaAction('migrate'));
-
-            migrate
-                .command('reset')
-                .description(
-                    `Resets your database and apply all migrations\nAlias for ${colors.cyan(
-                        'prisma migrate reset'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .option('--force', 'Skip the confirmation prompt')
-                .action(prismaAction('migrate'));
-
-            migrate
-                .command('deploy')
-                .description(
-                    `Applies pending migrations to the database in production/staging\nAlias for ${colors.cyan(
-                        'prisma migrate deploy'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .action(prismaAction('migrate'));
-
-            migrate
-                .command('status')
-                .description(
-                    `Checks the status of migrations in the production/staging database\nAlias for ${colors.cyan(
-                        'prisma migrate status'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .action(prismaAction('migrate'));
-
-            const db = program
-                .command('db')
-                .description(
-                    `Manages your database schema and lifecycle during development\nAlias for ${colors.cyan(
-                        'prisma db'
-                    )}.`
-                );
-
-            db.command('push')
-                .description(
-                    `Pushes the Prisma schema state to the database\nAlias for ${colors.cyan(
-                        'prisma db push'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .option('--accept-data-loss', 'Ignore data loss warnings')
-                .action(prismaAction('db'));
-
-            program
-                .command('studio')
-                .description(
-                    `Browses your data with Prisma Studio\nAlias for ${colors.cyan(
-                        'prisma studio'
-                    )}.`
-                )
-                .addOption(schemaOption)
-                .option('-p --port <port>', 'Port to start Studio in')
-                .option('-b --browser <browser>', 'Browser to open Studio in')
-                .option(
-                    '-n --hostname',
-                    'Hostname to bind the Express server to'
-                )
-                .action(prismaAction(''));
-
-            //#endregion
-
-            // handle errors explicitly to ensure telemetry
-            program.exitOverride();
-
-            await program.parseAsync(process.argv);
-        }
-    );
-}

package/src/extension.ts

@@ -1,76 +0,0 @@
-import * as vscode from 'vscode';
-import * as path from 'path';
-import {
-    LanguageClient,
-    LanguageClientOptions,
-    ServerOptions,
-    TransportKind,
-} from 'vscode-languageclient/node';
-
-let client: LanguageClient;
-
-// This function is called when the extension is activated.
-export function activate(context: vscode.ExtensionContext): void {
-    client = startLanguageClient(context);
-}
-
-// This function is called when the extension is deactivated.
-export function deactivate(): Thenable<void> | undefined {
-    if (client) {
-        return client.stop();
-    }
-    return undefined;
-}
-
-function startLanguageClient(context: vscode.ExtensionContext): LanguageClient {
-    const serverModule = context.asAbsolutePath(
-        path.join('bundle', 'language-server', 'main')
-    );
-    // The debug options for the server
-    // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging.
-    // By setting `process.env.DEBUG_BREAK` to a truthy value, the language server will wait until a debugger is attached.
-    const debugOptions = {
-        execArgv: [
-            '--nolazy',
-            `--inspect${process.env.DEBUG_BREAK ? '-brk' : ''}=${
-                process.env.DEBUG_SOCKET || '6009'
-            }`,
-        ],
-    };
-
-    // If the extension is launched in debug mode then the debug server options are used
-    // Otherwise the run options are used
-    const serverOptions: ServerOptions = {
-        run: { module: serverModule, transport: TransportKind.ipc },
-        debug: {
-            module: serverModule,
-            transport: TransportKind.ipc,
-            options: debugOptions,
-        },
-    };
-
-    const fileSystemWatcher =
-        vscode.workspace.createFileSystemWatcher('**/*.zmodel');
-    context.subscriptions.push(fileSystemWatcher);
-
-    // Options to control the language client
-    const clientOptions: LanguageClientOptions = {
-        documentSelector: [{ scheme: 'file', language: 'zmodel' }],
-        synchronize: {
-            // Notify the server about file changes to files contained in the workspace
-            fileEvents: fileSystemWatcher,
-        },
-    };
-
-    // Create the language client and start the client.
-    const client = new LanguageClient(
-        'zmodel',
-        'ZenStack Model',
-        serverOptions,
-        clientOptions
-    );
-
-    // Start the client. This will also launch the server
-    client.start();
-    return client;
-}

package/src/generator/ast-utils.ts

@@ -1,18 +0,0 @@
-import { DataModel, isDataModel, Model } from '@lang/generated/ast';
-import { AstNode, Reference } from 'langium';
-import { GeneratorError } from './types';
-
-export function extractDataModelsWithAllowRules(model: Model): DataModel[] {
-    return model.declarations.filter(
-        (d) =>
-            isDataModel(d) &&
-            !!d.attributes.find((attr) => attr.decl.ref?.name === '@@allow')
-    ) as DataModel[];
-}
-
-export function resolved<T extends AstNode>(ref: Reference<T>): T {
-    if (!ref.ref) {
-        throw new GeneratorError(`Reference not resolved: ${ref.$refText}`);
-    }
-    return ref.ref;
-}

package/src/generator/constants.ts

@@ -1,6 +0,0 @@
-export const RUNTIME_PACKAGE = '@zenstackhq/runtime';
-export const GUARD_FIELD_NAME = 'zenstack_guard';
-export const TRANSACTION_FIELD_NAME = 'zenstack_transaction';
-export const API_ROUTE_NAME = 'zenstack';
-export const GENERATED_CODE_PATH = 'node_modules/.zenstack';
-export const UNKNOWN_USER_ID = 'zenstack_unknown_user';

package/src/generator/field-constraint/index.ts

@@ -1,304 +0,0 @@
-import {
-    DataModel,
-    DataModelField,
-    DataModelFieldAttribute,
-    isDataModel,
-    isLiteralExpr,
-    LiteralExpr,
-} from '@lang/generated/ast';
-import * as path from 'path';
-import { Project, SourceFile } from 'ts-morph';
-import { Context, Generator } from '../types';
-
-/**
- * Generates field constraint validators (run on both client and server side)
- */
-export default class FieldConstraintGenerator implements Generator {
-    get name() {
-        return 'field-constraint';
-    }
-
-    get startMessage() {
-        return 'Generating field constraints...';
-    }
-
-    get successMessage() {
-        return 'Successfully generated field constraints';
-    }
-
-    async generate(context: Context) {
-        const project = new Project();
-        const sf = project.createSourceFile(
-            path.join(
-                context.generatedCodeDir,
-                'src/field-constraint/index.ts'
-            ),
-            undefined,
-            { overwrite: true }
-        );
-
-        sf.addStatements([`import { z } from "zod";`]);
-
-        context.schema.declarations
-            .filter((d): d is DataModel => isDataModel(d))
-            .forEach((model) => {
-                this.generateConstraints(sf, model);
-            });
-
-        sf.formatText();
-        await project.save();
-
-        return [];
-    }
-
-    private generateConstraints(sf: SourceFile, model: DataModel) {
-        sf.addStatements(`
-            export const ${this.validator(
-                model.name,
-                'create'
-            )}: z.ZodType = z.lazy(() => z.object({
-                ${model.fields
-                    .map((f) => ({
-                        field: f,
-                        schema: this.makeFieldValidator(f, 'create'),
-                    }))
-                    .filter(({ schema }) => !!schema)
-                    .map(({ field, schema }) => field.name + ': ' + schema)
-                    .join(',\n')}
-            }));
-
-            export const ${this.validator(
-                model.name,
-                'update'
-            )}: z.ZodType = z.lazy(() => z.object({
-                ${model.fields
-                    .map((f) => ({
-                        field: f,
-                        schema: this.makeFieldValidator(f, 'update'),
-                    }))
-                    .filter(({ schema }) => !!schema)
-                    .map(({ field, schema }) => field.name + ': ' + schema)
-                    .join(',\n')}
-            }).partial());     
-            `);
-    }
-
-    private makeFieldValidator(
-        field: DataModelField,
-        mode: 'create' | 'update'
-    ) {
-        const baseSchema = this.makeZodSchema(field, mode);
-        let zodSchema = baseSchema;
-
-        // translate field constraint attributes to zod schema
-        for (const attr of field.attributes) {
-            switch (attr.decl.ref?.name) {
-                case '@length': {
-                    const min = this.getAttrLiteralArg<number>(attr, 'min');
-                    if (min) {
-                        zodSchema += `.min(${min})`;
-                    }
-                    const max = this.getAttrLiteralArg<number>(attr, 'max');
-                    if (max) {
-                        zodSchema += `.max(${max})`;
-                    }
-                    break;
-                }
-                case '@regex': {
-                    const expr = this.getAttrLiteralArg<string>(attr, 'regex');
-                    if (expr) {
-                        zodSchema += `.regex(/${expr}/)`;
-                    }
-                    break;
-                }
-                case '@startsWith': {
-                    const text = this.getAttrLiteralArg<string>(attr, 'text');
-                    if (text) {
-                        zodSchema += `.startsWith(${JSON.stringify(text)})`;
-                    }
-                    break;
-                }
-                case '@endsWith': {
-                    const text = this.getAttrLiteralArg<string>(attr, 'text');
-                    if (text) {
-                        zodSchema += `.endsWith(${JSON.stringify(text)})`;
-                    }
-                    break;
-                }
-                case '@email': {
-                    zodSchema += `.email()`;
-                    break;
-                }
-                case '@url': {
-                    zodSchema += `.url()`;
-                    break;
-                }
-                case '@datetime': {
-                    zodSchema += `.datetime({ offset: true })`;
-                    break;
-                }
-                case '@gt': {
-                    const value = this.getAttrLiteralArg<number>(attr, 'value');
-                    if (value !== undefined) {
-                        zodSchema += `.gt(${value})`;
-                    }
-                    break;
-                }
-                case '@gte': {
-                    const value = this.getAttrLiteralArg<number>(attr, 'value');
-                    if (value !== undefined) {
-                        zodSchema += `.gte(${value})`;
-                    }
-                    break;
-                }
-                case '@lt': {
-                    const value = this.getAttrLiteralArg<number>(attr, 'value');
-                    if (value !== undefined) {
-                        zodSchema += `.lt(${value})`;
-                    }
-                    break;
-                }
-                case '@lte': {
-                    const value = this.getAttrLiteralArg<number>(attr, 'value');
-                    if (value !== undefined) {
-                        zodSchema += `.lte(${value})`;
-                    }
-                    break;
-                }
-            }
-        }
-
-        if (
-            !isDataModel(field.type.reference?.ref) &&
-            zodSchema === baseSchema
-        ) {
-            // empty schema, skip
-            return undefined;
-        }
-
-        if (field.type.optional) {
-            zodSchema = this.optional(zodSchema);
-        }
-
-        return zodSchema;
-    }
-
-    private getAttrLiteralArg<T extends string | number>(
-        attr: DataModelFieldAttribute,
-        paramName: string
-    ) {
-        const arg = attr.args.find(
-            (arg) => arg.$resolvedParam?.name === paramName
-        );
-        if (!arg || !isLiteralExpr(arg.value)) {
-            return undefined;
-        }
-        return (arg.value as LiteralExpr).value as T;
-    }
-
-    private makeZodSchema(field: DataModelField, mode: 'create' | 'update') {
-        const type = field.type;
-        let schema = '';
-        if (type.reference && isDataModel(type.reference.ref)) {
-            const modelType = type.reference.ref.name;
-            const create = this.validator(modelType, 'create');
-            const update = this.validator(modelType, 'update');
-
-            // list all possible action fields in write playload:
-            //   create/createMany/connectOrCreate/update/updateMany/upsert
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let fields: any = {
-                create: this.optional(this.enumerable(create)),
-                createMany: this.optional(this.enumerable(create)),
-                connectOrCreate: this.optional(
-                    this.enumerable(this.object({ create }))
-                ),
-            };
-
-            if (mode === 'update') {
-                fields = {
-                    ...fields,
-                    update: this.optional(
-                        this.enumerable(
-                            type.array ? this.object({ data: update }) : update
-                        )
-                    ),
-                    updateMany: this.optional(
-                        this.enumerable(this.object({ data: update }))
-                    ),
-                    upsert: this.optional(
-                        type.array
-                            ? this.enumerable(
-                                  this.object({
-                                      create,
-                                      update,
-                                  })
-                              )
-                            : this.object({
-                                  create,
-                                  update,
-                              })
-                    ),
-                };
-            }
-
-            schema = this.optional(this.object(fields));
-        } else {
-            switch (type.type) {
-                case 'Int':
-                case 'Float':
-                case 'Decimal':
-                    schema = 'z.number()';
-                    break;
-                case 'BigInt':
-                    schema = 'z.bigint()';
-                    break;
-                case 'String':
-                    schema = 'z.string()';
-                    break;
-                case 'Boolean':
-                    schema = 'z.boolean()';
-                    break;
-                case 'DateTime':
-                    schema = 'z.date()';
-                    break;
-                default:
-                    schema = 'z.any()';
-                    break;
-            }
-
-            if (type.array) {
-                schema = this.array(schema);
-            }
-        }
-
-        return schema;
-    }
-
-    private union(...schemas: string[]) {
-        return `z.union([${schemas.join(', ')}])`;
-    }
-
-    private optional(schema: string) {
-        return `z.optional(${schema})`;
-    }
-
-    private array(schema: string) {
-        return `z.array(${schema})`;
-    }
-
-    private enumerable(schema: string) {
-        return this.union(schema, this.array(schema));
-    }
-
-    private object(fields: Record<string, string>) {
-        return `z.object({ ${Object.entries(fields)
-            .map(([k, v]) => k + ': ' + v)
-            .join(',\n')} })`;
-    }
-
-    private validator(modelName: string, mode: 'create' | 'update') {
-        return `${modelName}_${mode}_validator`;
-    }
-}