zenstack 1.0.0 → 1.0.16

package/packages/schema/langium-quickstart.md

@@ -1,41 +0,0 @@
-# Welcome to your Langium VS Code Extension
-
-## What's in the folder
-
-This folder contains all necessary files for your language extension.
-
--   `package.json` - the manifest file in which you declare your language support.
--   `language-configuration.json` - the language configuration used in the VS Code editor, defining the tokens that are used for comments and brackets.
--   `src/extension.ts` - the main code of the extension, which is responsible for launching a language server and client.
--   `src/language-server/zmodel.langium` - the grammar definition of your language.
--   `src/language-server/main.ts` - the entry point of the language server process.
--   `src/language-server/zmodel-module.ts` - the dependency injection module of your language implementation. Use this to register overridden and added services.
--   `src/language-server/zmodel-validator.ts` - an example validator. You should change it to reflect the semantics of your language.
--   `src/cli/index.ts` - the entry point of the command line interface (CLI) of your language.
--   `src/cli/generator.ts` - the code generator used by the CLI to write output files from DSL documents.
--   `src/cli/cli-util.ts` - utility code for the CLI.
-
-## Get up and running straight away
-
--   Run `npm run langium:generate` to generate TypeScript code from the grammar definition.
--   Run `npm run build` to compile all TypeScript code.
--   Press `F5` to open a new window with your extension loaded.
--   Create a new file with a file name suffix matching your language.
--   Verify that syntax highlighting, validation, completion etc. are working as expected.
--   Run `./bin/cli` to see options for the CLI; `./bin/cli generate <file>` generates code for a given DSL file.
-
-## Make changes
-
--   Run `npm run watch` to have the TypeScript compiler run automatically after every change of the source files.
--   Run `npm run langium:watch` to have the Langium generator run automatically afer every change of the grammar declaration.
--   You can relaunch the extension from the debug toolbar after making changes to the files listed above.
--   You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
-
-## Install your extension
-
--   To start using your extension with VS Code, copy it into the `<user home>/.vscode/extensions` folder and restart Code.
--   To share your extension with the world, read the [VS Code documentation](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) about publishing an extension.
-
-## To Go Further
-
-Documentation about the Langium framework is available at https://langium.org

package/packages/schema/language-configuration.json

@@ -1,30 +0,0 @@
-{
-    "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

@@ -1,96 +0,0 @@
-{
-    "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

@@ -1,80 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -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('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

@@ -1,5 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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/packages/schema/src/generator/next-auth/index.ts

@@ -1,197 +0,0 @@
-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: 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: Project, context: Context) {
-        const content = `
-        import { ZenStackService } from '..';
-        import { Adapter } from 'next-auth/adapters';
-        import { Prisma } from '../../.prisma';
-        
-        export function NextAuthAdapter(service: ZenStackService): Adapter {
-            const db = service.db;
-            return {
-                createUser: (data) => db.user.create({ data: data as Prisma.UserCreateInput }),
-                getUser: (id) => db.user.findUnique({ where: { id } }),
-                getUserByEmail: (email) => db.user.findUnique({ where: { email } }),
-                async getUserByAccount(provider_providerAccountId) {
-                    const account = await db.account.findUnique({
-                        where: { provider_providerAccountId },
-                        select: { user: true },
-                    });
-                    return account?.user ?? null;
-                },
-                updateUser: (data) => db.user.update({ where: { id: data.id }, data: data as Prisma.UserUpdateInput }),
-                deleteUser: (id) => db.user.delete({ where: { id } }),
-                linkAccount: (data) => db.account.create({ data }) as any,
-                unlinkAccount: (provider_providerAccountId) =>
-                    db.account.delete({ where: { provider_providerAccountId } }) as any,
-                async getSessionAndUser(sessionToken) {
-                    const userAndSession = await db.session.findUnique({
-                        where: { sessionToken },
-                        include: { user: true },
-                    });
-                    if (!userAndSession) return null;
-                    const { user, ...session } = userAndSession;
-                    return { user, session };
-                },
-                createSession: (data) => db.session.create({ data }),
-                updateSession: (data) =>
-                    db.session.update({
-                        data,
-                        where: { sessionToken: data.sessionToken },
-                    }),
-                deleteSession: (sessionToken) =>
-                    db.session.delete({ where: { sessionToken } }),
-                createVerificationToken: (data) => db.verificationToken.create({ data }),
-                async useVerificationToken(identifier_token) {
-                    try {
-                        return await db.verificationToken.delete({
-                            where: { identifier_token },
-                        });
-                    } catch (error) {
-                        // If token already used/deleted, just return null
-                        // https://www.prisma.io/docs/reference/api-reference/error-reference#p2025
-                        if (
-                            (error as Prisma.PrismaClientKnownRequestError).code ===
-                            'P2025'
-                        )
-                            return null;
-                        throw error;
-                    }
-                },
-            };
-        }                
-        `;
-
-        const sf = project.createSourceFile(
-            path.join(
-                context.generatedCodeDir,
-                'src/auth/next-auth-adapter.ts'
-            ),
-            content,
-            { overwrite: true }
-        );
-
-        sf.formatText();
-    }
-
-    generateAuthorize(project: Project, context: Context) {
-        const content = `
-        import { ZenStackService } from '..';
-        import { hash, compare } from 'bcryptjs';
-        
-        async function hashPassword(password: string) {
-            const hashedPassword = await hash(password, 12);
-            return hashedPassword;
-        }
-        
-        async function verifyPassword(password: string, hashedPassword: string) {
-            const isValid = await compare(password, hashedPassword);
-            return isValid;
-        }
-        
-        export function authorize(service: ZenStackService) {
-            return async (
-                credentials: Record<'email' | 'password', string> | undefined
-            ) => {
-                if (!credentials) {
-                    throw new Error('Missing credentials');
-                }
-
-                try {
-                    let maybeUser = await service.db.user.findFirst({
-                        where: {
-                            email: credentials!.email,
-                        },
-                        select: {
-                            id: true,
-                            email: true,
-                            password: true,
-                            name: true,
-                        },
-                    });
-        
-                    if (!maybeUser) {
-                        if (!credentials.password || !credentials.email) {
-                            throw new Error('Invalid Credentials');
-                        }
-        
-                        maybeUser = await service.db.user.create({
-                            data: {
-                                email: credentials.email,
-                                password: await hashPassword(credentials.password),
-                            },
-                            select: {
-                                id: true,
-                                email: true,
-                                password: true,
-                                name: true,
-                            },
-                        });
-                    } else {
-                        if (!maybeUser.password) {
-                            throw new Error('Invalid User Record');
-                        }
-
-                        const isValid = await verifyPassword(
-                            credentials.password,
-                            maybeUser.password
-                        );
-        
-                        if (!isValid) {
-                            throw new Error('Invalid Credentials');
-                        }
-                    }
-        
-                    return {
-                        id: maybeUser.id,
-                        email: maybeUser.email,
-                        name: maybeUser.name,
-                    };
-                } catch (error) {
-                    console.log(error);
-                    throw error;
-                }
-            };
-        }
-        `;
-
-        const sf = project.createSourceFile(
-            path.join(context.generatedCodeDir, 'src/auth/authorize.ts'),
-            content,
-            { overwrite: true }
-        );
-
-        sf.formatText();
-    }
-}