zenstack 0.1.0

package/src/generator/react-hooks/index.ts

@@ -0,0 +1,267 @@
+import { Context, Generator } from '../types';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import { camelCase, paramCase } from 'change-case';
+import { DataModel } from '@lang/generated/ast';
+import colors from 'colors';
+import { extractDataModelsWithAllowRules } from '../utils';
+
+export default class ReactHooksGenerator implements Generator {
+    async generate(context: Context) {
+        const project = new Project();
+
+        const models = extractDataModelsWithAllowRules(context.schema);
+
+        this.generateIndex(project, context, models);
+        this.generateRequestRuntime(project, context);
+
+        models.forEach((d) => this.generateModelHooks(project, context, d));
+
+        await project.save();
+
+        console.log(colors.blue('  ✔️ React hooks generated'));
+    }
+
+    private generateRequestRuntime(project: Project, context: Context) {
+        const content = `
+        import useSWR, { useSWRConfig } from 'swr';
+        import type { ScopedMutator } from 'swr/dist/types';
+        
+        const fetcher = async (url: string, options?: RequestInit) => {
+            const res = await fetch(url, options);
+            if (!res.ok) {
+                const error: Error & { info?: any; status?: number } = new Error(
+                    'An error occurred while fetching the data.'
+                );
+                error.info = await res.json();
+                error.status = res.status;
+                throw error;
+            }
+            return res.json();
+        };
+        
+        function makeUrl(url: string, args: unknown) {
+            return args ? url + \`q=\${encodeURIComponent(JSON.stringify(args))}\` : url;
+        }
+        
+        export function get<Data, Error = any>(url: string, args?: unknown) {
+            return useSWR<Data, Error>(makeUrl(url, args), fetcher);
+        }
+        
+        export async function post<Data, Result>(
+            url: string,
+            data: Data,
+            mutate: ScopedMutator<any>
+        ) {
+            const r: Result = await fetcher(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(data),
+            });
+            mutate(url);
+            return r;
+        }
+        
+        export async function put<Data, Result>(
+            url: string,
+            data: Data,
+            mutate: ScopedMutator<any>
+        ) {
+            const r: Result = await fetcher(url, {
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(data),
+            });
+            mutate(url, r);
+            return r;
+        }
+        
+        export async function del<Result>(
+            url: string,
+            args: unknown,
+            mutate: ScopedMutator<any>
+        ) {
+            const reqUrl = makeUrl(url, args);
+            const r: Result = await fetcher(reqUrl, {
+                method: 'DELETE',
+            });
+            const path = url.split('/');
+            path.pop();
+            mutate(path.join('/'));
+            return r;
+        }
+        
+        export function getMutate() {
+            const { mutate } = useSWRConfig();
+            return mutate;
+        }
+        `;
+
+        const sf = project.createSourceFile(
+            path.join(context.outDir, `hooks/request.ts`),
+            content,
+            { overwrite: true }
+        );
+        sf.formatText();
+    }
+
+    private generateModelHooks(
+        project: Project,
+        context: Context,
+        model: DataModel
+    ) {
+        const fileName = paramCase(model.name);
+        const sf = project.createSourceFile(
+            path.join(context.outDir, `hooks/${fileName}.ts`),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addImportDeclaration({
+            namedImports: [{ name: 'Prisma', alias: 'P' }, model.name],
+            isTypeOnly: true,
+            moduleSpecifier: '../.prisma',
+        });
+
+        sf.addStatements([`import * as request from './request';`]);
+
+        sf.addStatements(
+            `const endpoint = '/api/zen/data/${camelCase(model.name)}';`
+        );
+
+        const useFuncBody = sf
+            .addFunction({
+                name: `use${model.name}`,
+                isExported: true,
+            })
+            .addBody();
+
+        useFuncBody.addStatements(['const mutate = request.getMutate();']);
+
+        // create
+        useFuncBody
+            .addFunction({
+                name: 'create',
+                isAsync: true,
+                typeParameters: [`T extends P.${model.name}CreateArgs`],
+                parameters: [
+                    { name: 'args', type: `P.${model.name}CreateArgs` },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.post<P.${model.name}CreateArgs, P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(endpoint, args, mutate);`,
+            ]);
+
+        // find
+        useFuncBody
+            .addFunction({
+                name: 'find',
+                typeParameters: [`T extends P.${model.name}FindManyArgs`],
+                parameters: [
+                    {
+                        name: 'args?',
+                        type: `P.SelectSubset<T, P.${model.name}FindManyArgs>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.get<P.CheckSelect<T, Array<${model.name}>, Array<P.${model.name}GetPayload<T>>>>(endpoint, args);`,
+            ]);
+
+        // get
+        useFuncBody
+            .addFunction({
+                name: 'get',
+                isAsync: true,
+                typeParameters: [
+                    `T extends P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>`,
+                ],
+                parameters: [
+                    {
+                        name: 'id',
+                        type: 'String',
+                    },
+                    {
+                        name: 'args?',
+                        type: `P.SelectSubset<T, P.Subset<P.${model.name}FindFirstArgs, 'select' | 'include'>>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.get<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args);`,
+            ]);
+
+        // update
+        useFuncBody
+            .addFunction({
+                name: 'update',
+                isAsync: true,
+                typeParameters: [
+                    `T extends Omit<P.${model.name}UpdateArgs, 'where'>`,
+                ],
+                parameters: [
+                    { name: 'id', type: 'String' },
+                    {
+                        name: 'args',
+                        type: `Omit<P.${model.name}UpdateArgs, 'where'>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.put<Omit<P.${model.name}UpdateArgs, 'where'>, P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);`,
+            ]);
+
+        // del
+        useFuncBody
+            .addFunction({
+                name: 'del',
+                isAsync: true,
+                typeParameters: [
+                    `T extends Omit<P.${model.name}DeleteArgs, 'where'>`,
+                ],
+                parameters: [
+                    { name: 'id', type: 'String' },
+                    {
+                        name: 'args?',
+                        type: `Omit<P.${model.name}DeleteArgs, 'where'>`,
+                    },
+                ],
+            })
+            .addBody()
+            .addStatements([
+                `return request.del<P.CheckSelect<T, ${model.name}, P.${model.name}GetPayload<T>>>(\`\${endpoint}/\${id}\`, args, mutate);`,
+            ]);
+
+        useFuncBody.addStatements([
+            'return { create, find, get, update, del };',
+        ]);
+
+        sf.formatText();
+    }
+
+    private generateIndex(
+        project: Project,
+        context: Context,
+        models: DataModel[]
+    ) {
+        const sf = project.createSourceFile(
+            path.join(context.outDir, 'hooks/index.ts'),
+            undefined,
+            { overwrite: true }
+        );
+
+        sf.addStatements(
+            models.map((d) => `export * from './${paramCase(d.name)}';`)
+        );
+
+        sf.formatText();
+    }
+}