zenstack 0.1.41 → 1.0.0

package/packages/schema/language-configuration.json

@@ -0,0 +1,30 @@
+{
+    "comments": {
+        // symbol used for single line comment. Remove this entry if your language does not support line comments
+        "lineComment": "//",
+        // symbols used for start and end a block comment. Remove this entry if your language does not support block comments
+        "blockComment": [ "/*", "*/" ]
+    },
+    // symbols used as brackets
+    "brackets": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"]
+    ],
+    // symbols that are auto closed when typing
+    "autoClosingPairs": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"]
+    ],
+    // symbols that can be used to surround a selection
+    "surroundingPairs": [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"]
+    ]
+}

package/packages/schema/package.json

@@ -0,0 +1,96 @@
+{
+    "name": "zenstack",
+    "displayName": "ZenStack CLI and Language Tools",
+    "description": "ZenStack CLI and Language Tools",
+    "version": "0.1.43",
+    "engines": {
+        "vscode": "^1.56.0"
+    },
+    "categories": [
+        "Programming Languages"
+    ],
+    "contributes": {
+        "languages": [
+            {
+                "id": "zmodel",
+                "aliases": [
+                    "ZenStack Model",
+                    "zmodel"
+                ],
+                "extensions": [
+                    ".zmodel"
+                ],
+                "configuration": "./language-configuration.json",
+                "icon": {
+                    "light": "./asset/logo-light.png",
+                    "dark": "./asset/logo-dark.png"
+                }
+            }
+        ],
+        "grammars": [
+            {
+                "language": "zmodel",
+                "scopeName": "source.zmodel",
+                "path": "./syntaxes/zmodel.tmLanguage.json"
+            }
+        ]
+    },
+    "activationEvents": [
+        "onLanguage:zmodel"
+    ],
+    "files": [
+        "bin",
+        "out"
+    ],
+    "bin": {
+        "zenstack": "./bin/cli"
+    },
+    "main": "./out/extension.js",
+    "scripts": {
+        "vscode:prepublish": "npm run build && npm run lint",
+        "build": "tsc && tsc-alias && cp src/language-server/stdlib.zmodel ./out/language-server/ && cp src/generator/*.template.json ./out/generator/",
+        "ts:watch": "tsc --watch",
+        "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\"",
+        "test": "jest",
+        "prepublishOnly": "pnpm build"
+    },
+    "dependencies": {
+        "@zenstackhq/internal": "workspace:*",
+        "change-case": "^4.1.2",
+        "chevrotain": "^9.1.0",
+        "colors": "^1.4.0",
+        "commander": "^8.0.0",
+        "langium": "^0.4.0",
+        "prisma": "^4.4.0",
+        "promisify": "^0.0.3",
+        "ts-morph": "^16.0.0",
+        "vscode-jsonrpc": "^8.0.2",
+        "vscode-languageclient": "^7.0.0",
+        "vscode-languageserver": "^7.0.0",
+        "vscode-uri": "^3.0.2"
+    },
+    "devDependencies": {
+        "@prisma/internals": "^4.4.0",
+        "@types/jest": "^29.0.3",
+        "@types/node": "^14.18.29",
+        "@types/tmp": "^0.2.3",
+        "@types/uuid": "^8.3.4",
+        "@types/vscode": "^1.56.0",
+        "@typescript-eslint/eslint-plugin": "^4.14.1",
+        "@typescript-eslint/parser": "^4.14.1",
+        "concurrently": "^7.4.0",
+        "eslint": "^7.19.0",
+        "jest": "^29.0.3",
+        "langium-cli": "^0.4.0",
+        "tmp": "^0.2.1",
+        "ts-jest": "^29.0.1",
+        "ts-node": "^10.9.1",
+        "tsc-alias": "^1.7.0",
+        "tsconfig-paths-jest": "^0.0.1",
+        "typescript": "^4.6.2"
+    }
+}

package/packages/schema/src/cli/cli-util.ts

@@ -0,0 +1,80 @@
+import colors from 'colors';
+import path from 'path';
+import fs from 'fs';
+import { AstNode, LangiumDocument, LangiumServices } from 'langium';
+import { URI } from 'vscode-uri';
+
+export async function extractDocument(
+    fileName: string,
+    services: LangiumServices
+): Promise<LangiumDocument> {
+    const extensions = services.LanguageMetaData.fileExtensions;
+    if (!extensions.includes(path.extname(fileName))) {
+        console.error(
+            colors.yellow(
+                `Please choose a file with one of these extensions: ${extensions}.`
+            )
+        );
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(fileName)) {
+        console.error(colors.red(`File ${fileName} does not exist.`));
+        process.exit(1);
+    }
+
+    const stdLib =
+        services.shared.workspace.LangiumDocuments.getOrCreateDocument(
+            URI.file(path.join(__dirname, '../language-server/stdlib.zmodel'))
+        );
+    const document =
+        services.shared.workspace.LangiumDocuments.getOrCreateDocument(
+            URI.file(path.resolve(fileName))
+        );
+    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;
+}
+
+export async function extractAstNode<T extends AstNode>(
+    fileName: string,
+    services: LangiumServices
+): Promise<T> {
+    return (await extractDocument(fileName, services)).parseResult?.value as T;
+}
+
+interface FilePathData {
+    destination: string;
+    name: string;
+}
+
+export function extractDestinationAndName(
+    filePath: string,
+    destination: string | undefined
+): FilePathData {
+    filePath = filePath.replace(/\..*$/, '').replace(/[.-]/g, '');
+    return {
+        destination:
+            destination ?? path.join(path.dirname(filePath), 'generated'),
+        name: path.basename(filePath),
+    };
+}

package/packages/schema/src/cli/index.ts

@@ -0,0 +1,64 @@
+import { Command } from 'commander';
+import { Model } from '../language-server/generated/ast';
+import { ZModelLanguageMetaData } from '../language-server/generated/module';
+import { createZModelServices } from '../language-server/zmodel-module';
+import { extractAstNode } from './cli-util';
+import { Context, GeneratorError } from '../generator/types';
+import { ZenStackGenerator } from '../generator';
+import { GENERATED_CODE_PATH } from '../generator/constants';
+import colors from 'colors';
+
+export const generateAction = async (
+    fileName: string,
+    opts: GenerateOptions
+): Promise<void> => {
+    const services = createZModelServices().ZModel;
+    const model = await extractAstNode<Model>(fileName, services);
+
+    const context: Context = {
+        schema: model,
+        outDir: opts.destination || './zenstack',
+        // 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);
+        }
+    }
+};
+
+export type GenerateOptions = {
+    destination?: string;
+};
+
+export default function (): void {
+    const program = new Command('zenstack');
+
+    program.version(
+        require('../../package.json').version,
+        '-v --version',
+        'display CLI version'
+    );
+
+    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.`
+    );
+
+    const fileExtensions = ZModelLanguageMetaData.fileExtensions.join(', ');
+    program
+        .command('generate')
+        .argument('<file>', `source file (with extension ${fileExtensions})`)
+        .description(
+            'generates RESTful API and Typescript client for your data model'
+        )
+        .action(generateAction);
+
+    program.parse(process.argv);
+}

package/packages/schema/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('out', '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/packages/schema/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/packages/schema/src/generator/index.ts

@@ -0,0 +1,92 @@
+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';
+
+export class ZenStackGenerator {
+    async generate(context: Context) {
+        // 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}`));
+
+        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,
+            '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,
+            '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!')
+            )
+        );
+    }
+}

package/{out/generator/next-auth/index.js → packages/schema/src/generator/next-auth/index.ts}

@@ -1,63 +1,37 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ts_morph_1 = require("ts-morph");
-const path = __importStar(require("path"));
-const colors_1 = __importDefault(require("colors"));
-class NextAuthGenerator {
-    generate(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const project = new ts_morph_1.Project();
-            this.generateIndex(project, context);
-            this.generateAdapter(project, context);
-            this.generateAuthorize(project, context);
-            yield project.save();
-            console.log(colors_1.default.blue(`  ✔️ Next-auth adapter generated`));
-        });
+import { Context, Generator } from '../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import colors from 'colors';
+
+export default class NextAuthGenerator implements Generator {
+    async generate(context: Context) {
+        const project = new Project();
+
+        this.generateIndex(project, context);
+        this.generateAdapter(project, context);
+        this.generateAuthorize(project, context);
+
+        await project.save();
+
+        console.log(colors.blue(`  ✔️ Next-auth adapter generated`));
     }
-    generateIndex(project, context) {
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/index.ts'), undefined, { overwrite: true });
+
+    generateIndex(project: Project, context: Context) {
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/auth/index.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
         sf.addStatements([
             `export * from './next-auth-adapter';`,
             `export * from './authorize';`,
         ]);
+
         sf.formatText();
     }
-    generateAdapter(project, context) {
+
+    generateAdapter(project: Project, context: Context) {
         const content = `
         import { ZenStackService } from '..';
         import { Adapter } from 'next-auth/adapters';
@@ -118,10 +92,20 @@ class NextAuthGenerator {
             };
         }                
         `;
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/next-auth-adapter.ts'), content, { overwrite: true });
+
+        const sf = project.createSourceFile(
+            path.join(
+                context.generatedCodeDir,
+                'src/auth/next-auth-adapter.ts'
+            ),
+            content,
+            { overwrite: true }
+        );
+
         sf.formatText();
     }
-    generateAuthorize(project, context) {
+
+    generateAuthorize(project: Project, context: Context) {
         const content = `
         import { ZenStackService } from '..';
         import { hash, compare } from 'bcryptjs';
@@ -201,9 +185,13 @@ class NextAuthGenerator {
             };
         }
         `;
-        const sf = project.createSourceFile(path.join(context.generatedCodeDir, 'src/auth/authorize.ts'), content, { overwrite: true });
+
+        const sf = project.createSourceFile(
+            path.join(context.generatedCodeDir, 'src/auth/authorize.ts'),
+            content,
+            { overwrite: true }
+        );
+
         sf.formatText();
     }
 }
-exports.default = NextAuthGenerator;
-//# sourceMappingURL=index.js.map