zenstack 0.1.47 → 0.1.50

package/bundle/res/stdlib.zmodel

@@ -0,0 +1,101 @@
+/*
+ * Enum representing referential integrity related actions
+ */
+enum ReferentialAction {
+    /*
+     * Used with "onDelete": deleting a referenced record will trigger the deletion of referencing record.
+     * Used with "onUpdate": updates the relation scalar fields if the referenced scalar fields of the dependent record are updated.
+     */
+    Cascade
+}
+
+/*
+ * Reads value from an environment variable
+ */
+function env(name: String): String {}
+
+/*
+ * Gets thec current login user
+ */
+function auth(): Any {}
+
+/*
+ * Gets current date-time (as DateTime type)
+ */
+function now(): DateTime {}
+
+/*
+ * Generate a globally unique identifier based on the UUID spec
+ */
+function uuid(): String {}
+
+/*
+ * Generate a globally unique identifier based on the CUID spec
+ */
+function cuid(): String {}
+
+/*
+ * Create a sequence of integers in the underlying database and assign the incremented 
+ * values to the ID values of the created records based on the sequence
+ */
+function autoincrement(): Int {}
+
+/*
+ * Represents default values that cannot be expressed in the Prisma schema (such as random()).
+ */
+function dbgenerated(expr: String): Any {}
+
+/*
+ * Defines an ID on the model
+ */
+attribute @id(map: String?)
+
+/*
+ * Defines a default value for a field
+ */
+attribute @default(_ value: ContextType)
+
+/*
+ * Defines a unique constraint for this field
+ */
+attribute @unique(map: String?)
+
+/*
+ * Defines a compound unique constraint for the specified fields
+ */
+attribute @@unique(_ fields: FieldReference[], name: String?, map: String?)
+
+/*
+ * Defines an index in the database
+ */
+attribute @@index(_ fields: FieldReference[], map: String?)
+
+/*
+ * Defines meta information about the relation
+ */
+attribute @relation(_ name: String?, fields: FieldReference[]?, references: FieldReference[]?, onDelete: ReferentialAction?, onUpdate: ReferentialAction?, map: String?)
+
+/*
+ * Maps a field name or enum value from the schema to a column with a different name in the database
+ */
+attribute @map(_ name: String)
+
+/*
+ * Maps the schema model name to a table with a different name, or an enum name to a different underlying enum in the database
+ */
+attribute @@map(_ name: String)
+
+/*
+ * Automatically stores the time when a record was last updated
+ */
+attribute @updatedAt()
+
+/*
+ * Defines an access policy that allows a set of operations when the given condition is true
+ */
+attribute @@allow(_ operation: String, _ condition: Boolean)
+
+/*
+ * Defines an access policy that denies a set of operations when the given condition is true
+ */
+attribute @@deny(_ operation: String, _ condition: Boolean)

package/package.json

@@ -1,10 +1,26 @@
 {
   "name": "zenstack",
-  "displayName": "ZenStack CLI and Language Tools",
-  "description": "ZenStack CLI and Language Tools",
-  "version": "0.1.47",
+  "publisher": "zenstack",
+  "displayName": "ZenStack Language Tools",
+  "description": "ZenStack is a toolkit that simplifies full-stack development",
+  "version": "0.1.50",
+  "author": {
+    "name": "ymc9"
+  },
+  "keywords": [
+    "fullstack",
+    "react",
+    "typescript",
+    "data modeling"
+  ],
+  "preview": true,
+  "icon": "asset/logo-light-256.png",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zenstackhq/zenstack"
+  },
   "engines": {
-    "vscode": "^1.56.0"
+    "vscode": "^1.72.0"
   },
   "categories": [
     "Programming Languages"
@@ -22,8 +38,8 @@
         ],
         "configuration": "./language-configuration.json",
         "icon": {
-          "light": "./asset/logo-light.png",
-          "dark": "./asset/logo-dark.png"
+          "light": "./asset/logo-light-256.png",
+          "dark": "./asset/logo-dark-256.png"
         }
       }
     ],
@@ -40,14 +56,15 @@
   ],
   "files": [
     "bin",
-    "out"
+    "src",
+    "bundle"
   ],
   "bin": {
     "zenstack": "./bin/cli"
   },
-  "main": "./out/extension.js",
+  "main": "./bundle/extension.js",
   "dependencies": {
-    "@zenstackhq/internal": "0.1.21",
+    "@zenstackhq/internal": "0.1.22",
     "change-case": "^4.1.2",
     "chevrotain": "^9.1.0",
     "colors": "^1.4.0",
@@ -61,6 +78,7 @@
     "vscode-jsonrpc": "^8.0.2",
     "vscode-languageclient": "^8.0.2",
     "vscode-languageserver": "^8.0.2",
+    "vscode-languageserver-textdocument": "^1.0.7",
     "vscode-uri": "^3.0.6"
   },
   "devDependencies": {
@@ -74,6 +92,7 @@
     "@typescript-eslint/eslint-plugin": "^4.33.0",
     "@typescript-eslint/parser": "^4.33.0",
     "concurrently": "^7.4.0",
+    "esbuild": "^0.15.12",
     "eslint": "^7.32.0",
     "jest": "^29.2.1",
     "langium-cli": "^0.5.0",
@@ -82,17 +101,22 @@
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.7.0",
     "tsconfig-paths-jest": "^0.0.1",
-    "typescript": "^4.8.4"
+    "typescript": "^4.8.4",
+    "vsce": "^2.13.0"
   },
   "scripts": {
-    "vscode:prepublish": "npm run build && npm run lint",
-    "build": "npm run langium:generate && tsc && tsc-alias && cp src/language-server/stdlib.zmodel ./out/language-server/ && cp src/generator/*.template.json ./out/generator/",
-    "ts:watch": "tsc --watch",
+    "vscode:publish": "vsce publish --no-dependencies",
+    "vscode:prepublish": "pnpm lint && pnpm build && pnpm bundle",
+    "vscode:package": "vsce package --no-dependencies",
+    "build": "pnpm langium:generate && tsc --noEmit",
+    "bundle": "node build/bundle.js --minify",
+    "bundle-watch": "node build/bundle.js --watch",
+    "ts:watch": "tsc --watch --noEmit",
     "tsc-alias:watch": "tsc-alias --watch",
     "lint": "eslint src --ext ts",
     "langium:generate": "langium generate",
     "langium:watch": "langium generate --watch",
-    "watch": "concurrently --kill-others \"npm:langium:watch\" \"npm:ts:watch\" \"npm:tsc-alias:watch\"",
+    "watch": "concurrently --kill-others \"npm:langium:watch\" \"npm:bundle-watch\"",
     "test": "jest"
   }
 }

package/src/cli/cli-util.ts

@@ -0,0 +1,71 @@
+import { STD_LIB_MODULE_NAME } from '@lang/constants';
+import { Model } from '@lang/generated/ast';
+import colors from 'colors';
+import fs from 'fs';
+import { LangiumServices } from 'langium';
+import path from 'path';
+import { URI } from 'vscode-uri';
+
+/**
+ * Loads a zmodel document from a file.
+ * @param fileName File name
+ * @param services Language services
+ * @returns Parsed and validated AST
+ */
+export async function loadDocument(
+    fileName: string,
+    services: LangiumServices
+): Promise<Model> {
+    const extensions = services.LanguageMetaData.fileExtensions;
+    if (!extensions.includes(path.extname(fileName))) {
+        console.error(
+            colors.yellow(`Please choose a file with extension: ${extensions}.`)
+        );
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(fileName)) {
+        console.error(colors.red(`File ${fileName} does not exist.`));
+        process.exit(1);
+    }
+
+    // load standard library
+    const stdLib =
+        services.shared.workspace.LangiumDocuments.getOrCreateDocument(
+            URI.file(
+                path.resolve(
+                    path.join(__dirname, '../res', STD_LIB_MODULE_NAME)
+                )
+            )
+        );
+
+    // load the document
+    const document =
+        services.shared.workspace.LangiumDocuments.getOrCreateDocument(
+            URI.file(path.resolve(fileName))
+        );
+
+    // build the document together with standard library
+    await services.shared.workspace.DocumentBuilder.build([stdLib, document], {
+        validationChecks: 'all',
+    });
+
+    const validationErrors = (document.diagnostics ?? []).filter(
+        (e) => e.severity === 1
+    );
+    if (validationErrors.length > 0) {
+        console.error(colors.red('There are validation errors:'));
+        for (const validationError of validationErrors) {
+            console.error(
+                colors.red(
+                    `line ${validationError.range.start.line + 1}: ${
+                        validationError.message
+                    } [${document.textDocument.getText(validationError.range)}]`
+                )
+            );
+        }
+        process.exit(1);
+    }
+
+    return document.parseResult.value as Model;
+}

package/src/cli/index.ts

@@ -0,0 +1,182 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Command, Option } from 'commander';
+import { NodeFileSystem } from 'langium/node';
+import { ZModelLanguageMetaData } from '../language-server/generated/module';
+import { createZModelServices } from '../language-server/zmodel-module';
+import { Context, GeneratorError } from '../generator/types';
+import { ZenStackGenerator } from '../generator';
+import { GENERATED_CODE_PATH } from '../generator/constants';
+import colors from 'colors';
+import { execSync } from '../utils/exec-utils';
+import { paramCase } from 'change-case';
+import path from 'path';
+import { loadDocument } from './cli-util';
+
+export const generateAction = async (options: {
+    schema: string;
+}): Promise<void> => {
+    const services = createZModelServices(NodeFileSystem).ZModel;
+    const model = await loadDocument(options.schema, services);
+
+    const context: Context = {
+        schema: model,
+        outDir: path.dirname(options.schema),
+        // TODO: make this configurable
+        generatedCodeDir: GENERATED_CODE_PATH,
+    };
+
+    try {
+        await new ZenStackGenerator().generate(context);
+    } catch (err) {
+        if (err instanceof GeneratorError) {
+            console.error(colors.red(err.message));
+            process.exit(1);
+        }
+    }
+};
+
+function prismaAction(prismaCmd: string): (...args: any[]) => Promise<void> {
+    return async (options: any, command: Command) => {
+        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(' ');
+        const prismaExec = `npx prisma ${prismaCmd} ${command.name()} ${optStr}`;
+        console.log(prismaExec);
+        try {
+            execSync(prismaExec);
+        } catch {
+            console.error(
+                colors.red(
+                    'Prisma command failed to execute. See errors above.'
+                )
+            );
+            process.exit(1);
+        }
+    };
+}
+
+export default function (): void {
+    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 simplifies fullstack development by generating backend services and Typescript clients from a data model.\n\nDocumentation: https://zenstack.dev/doc.`
+        )
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+
+    const schemaOption = new Option(
+        '--schema <file>',
+        `schema file (with extension ${schemaExtensions})`
+    ).default('./zenstack/schema.zmodel');
+
+    //#region wraps Prisma commands
+
+    program
+        .command('generate')
+        .description(
+            'generates RESTful API and Typescript client for your data model'
+        )
+        .addOption(schemaOption)
+        .action(generateAction);
+
+    const migrate = program
+        .command('migrate')
+        .description(`wraps Prisma's ${colors.cyan('migrate')} command`);
+
+    migrate
+        .command('dev')
+        .description(
+            `alias for ${colors.cyan(
+                'prisma migrate dev'
+            )}\nCreate a migration, apply it to the database, generate db client.`
+        )
+        .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(
+            `alias for ${colors.cyan(
+                'prisma migrate reset'
+            )}\nReset your database and apply all migrations.`
+        )
+        .addOption(schemaOption)
+        .option('--force', 'Skip the confirmation prompt')
+        .action(prismaAction('migrate'));
+
+    migrate
+        .command('deploy')
+        .description(
+            `alias for ${colors.cyan(
+                'prisma migrate deploy'
+            )}\nApply pending migrations to the database in production/staging.`
+        )
+        .addOption(schemaOption)
+        .action(prismaAction('migrate'));
+
+    migrate
+        .command('status')
+        .description(
+            `alias for ${colors.cyan(
+                'prisma migrate status'
+            )}\nCheck the status of migrations in the production/staging database.`
+        )
+        .addOption(schemaOption)
+        .action(prismaAction('migrate'));
+
+    const db = program
+        .command('db')
+        .description(`wraps Prisma's ${colors.cyan('db')} command`);
+
+    db.command('push')
+        .description(
+            `alias for ${colors.cyan(
+                'prisma db push'
+            )}\nPush the Prisma schema state to the database.`
+        )
+        .addOption(schemaOption)
+        .option('--accept-data-loss', 'Ignore data loss warnings')
+        .action(prismaAction('db'));
+
+    program
+        .command('studio')
+        .description(
+            `wraps Prisma's ${colors.cyan(
+                'studio'
+            )} command. Browse your data with 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
+
+    program.parse(process.argv);
+}

package/src/extension.ts

@@ -0,0 +1,76 @@
+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/constants.ts

@@ -0,0 +1,5 @@
+export const INTERNAL_PACKAGE = '@zenstackhq/internal';
+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';

package/src/generator/index.ts

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { Context, GeneratorError } from './types';
+import * as fs from 'fs';
+import colors from 'colors';
+import PrismaGenerator from './prisma';
+import ServiceGenerator from './service';
+import ReactHooksGenerator from './react-hooks';
+import NextAuthGenerator from './next-auth';
+import path from 'path';
+import { execSync } from '../utils/exec-utils';
+
+/**
+ * ZenStack code generator
+ */
+export class ZenStackGenerator {
+    /**
+     * Runs a series of nested generators
+     */
+    async generate(context: Context): Promise<void> {
+        // folder that stores generated prisma schema and migrations
+        if (!fs.existsSync(context.outDir)) {
+            fs.mkdirSync(context.outDir);
+        }
+
+        // folder that stores generated zenstack code
+        if (fs.existsSync(context.generatedCodeDir)) {
+            fs.rmSync(context.generatedCodeDir, {
+                force: true,
+                recursive: true,
+            });
+        }
+        fs.mkdirSync(context.generatedCodeDir);
+
+        const version = require('../../package.json').version;
+        console.log(colors.bold(`⌛️ Running ZenStack generator v${version}`));
+
+        // TODO: plugin mechanism
+        const generators = [
+            new PrismaGenerator(),
+            new ServiceGenerator(),
+            new ReactHooksGenerator(),
+        ];
+
+        try {
+            require('next-auth');
+            generators.push(new NextAuthGenerator());
+        } catch {
+            console.warn(
+                colors.yellow(
+                    'Next-auth module is not installed, skipping generating adapter.'
+                )
+            );
+        }
+
+        for (const generator of generators) {
+            await generator.generate(context);
+        }
+
+        // generate package.json
+        const packageJson = require(path.join(
+            __dirname,
+            '../res',
+            'package.template.json'
+        ));
+        fs.writeFileSync(
+            path.join(context.generatedCodeDir, 'package.json'),
+            JSON.stringify(packageJson, undefined, 4)
+        );
+
+        // compile ts sources
+        const tsConfig = require(path.join(
+            __dirname,
+            '../res',
+            'tsconfig.template.json'
+        ));
+        fs.writeFileSync(
+            path.join(context.generatedCodeDir, 'tsconfig.json'),
+            JSON.stringify(tsConfig, undefined, 4)
+        );
+
+        try {
+            execSync(
+                `npx tsc -p "${path.join(
+                    context.generatedCodeDir,
+                    'tsconfig.json'
+                )}"`
+            );
+        } catch {
+            throw new GeneratorError(
+                'Something went wrong, generated runtime code failed to compile...\nPlease check errors above.'
+            );
+        }
+
+        console.log(colors.blue('  ✔️ Typescript source files transpiled'));
+
+        console.log(
+            colors.green(
+                colors.bold('👻 All generators completed successfully!')
+            )
+        );
+    }
+}