zenstack 0.1.0

package/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/src/cli/index.ts

@@ -0,0 +1,80 @@
+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 } from '../generator/types';
+import * as path from 'path';
+import * as fs from 'fs';
+import colors from 'colors';
+import PrismaGenerator from '../generator/prisma';
+import ServiceGenerator from '../generator/service';
+import ReactHooksGenerator from '../generator/react-hooks';
+import NextAuthGenerator from '../generator/next-auth';
+import ServerGenerator from '../generator/server';
+
+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: path.resolve(opts.destination),
+    };
+
+    if (!fs.existsSync(context.outDir)) {
+        fs.mkdirSync(context.outDir);
+    }
+
+    console.log(colors.bold('⌛️ Running ZenStack generators'));
+
+    const generators = [
+        new PrismaGenerator(),
+        new ServiceGenerator(),
+        new ReactHooksGenerator(),
+        new ServerGenerator(),
+        new NextAuthGenerator(),
+    ];
+
+    for (const generator of generators) {
+        await generator.generate(context);
+    }
+
+    console.log(
+        colors.green(colors.bold('👻 All generators completed successfully!'))
+    );
+};
+
+export type GenerateOptions = {
+    destination: string;
+};
+
+export default function (): void {
+    const program = new Command();
+
+    program
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        .version(require('../../package.json').version);
+
+    const fileExtensions = ZModelLanguageMetaData.fileExtensions.join(', ');
+    program
+        .command('generate')
+        .argument(
+            '<file>',
+            `source file (possible file extensions: ${fileExtensions})`
+        )
+        .option(
+            '-d, --destination <dir>',
+            'destination directory of generating',
+            '.zenstack'
+        )
+        .description(
+            'generates JavaScript code that prints "Hello, {name}!" for each greeting in a source file'
+        )
+        .action(generateAction);
+
+    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('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/src/generator/next-auth/index.ts

@@ -0,0 +1,183 @@
+import { Context, Generator } from '../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+
+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();
+    }
+
+    generateIndex(project: Project, context: Context) {
+        const sf = project.createSourceFile(
+            path.join(context.outDir, '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 '../service';
+        import { Adapter } from 'next-auth/adapters';
+        import { Prisma } from '@zenstack/.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.outDir, 'auth/next-auth-adapter.ts'),
+            content,
+            { overwrite: true }
+        );
+
+        sf.formatText();
+    }
+
+    generateAuthorize(project: Project, context: Context) {
+        const content = `
+        import { ZenStackService } from '../service';
+        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
+            ) => {
+                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 {
+                        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.outDir, 'auth/authorize.ts'),
+            content,
+            { overwrite: true }
+        );
+
+        sf.formatText();
+    }
+}