@appxdigital/appx-core-cli 1.0.6 → 1.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "@appxdigital/appx-core-cli",
-    "version": "1.0.6",
+    "version": "1.0.7",
     "main": "index.js",
     "scripts": {
         "npm:publish": "npm publish --access public",

package/templates/admin.config.template.js

@@ -0,0 +1,25 @@
+import { AdminConfigType } from '@appxdigital/appx-core';
+import { ComponentLoader } from 'adminjs';
+
+const componentLoader = new ComponentLoader();
+
+export const AdminConfig: AdminConfigType = {
+    componentLoader,
+    resources: [
+        {
+            name: 'User',
+        },
+    ],
+    rootPath: '/admin',
+    branding: {
+        companyName: 'AppX Core',
+        logo: 'https://appx-website-assets.fra1.cdn.digitaloceanspaces.com/2024/04/logo_color.svg',
+    },
+    // As you can see below, you can customize the dashboard component, which is the first page you see when you access the AdminJS
+    dashboard: {
+        component: componentLoader.add(
+            'Dashboard',
+            '../backoffice/components/dashboard',
+        ),
+    },
+};

package/templates/adminjs/dashboard.template.js

@@ -1,37 +1,10 @@
 import React from 'react';
 
 export const Dashboard = () => {
+    // Redirect to Users resource
+    window.location.href = window.location.href + '/resources/User';
 
-    return (
-        <div style={{
-            backgroundColor: 'white',
-            borderRadius: '15px',
-            height: '100%',
-            padding: '1rem',
-            margin: '1rem',
-        }}>
-            <h1 style={{ fontSize: "1.5rem", textAlign: "center" }}>Dashboard</h1>
-            <div style={{
-                display: 'flex',
-                gap: '1rem',
-                flexDirection: 'column',
-                textAlign: 'center',
-                marginTop: '3rem',
-                borderRadius: '15px',
-                border: '2px solid gainsboro',
-                maxWidth: '300px',
-                margin: '3rem auto',
-                padding: '1rem',
-            }}>
-                <h2>Customize it!</h2>
-                <p>You can customize your dashboard however you want.</p>
-                <p>Display any data you might find useful.</p>
-                <p>See the number of users or check statistics on graphics</p>
-                <p>Whatever you want to do! Edit it on components/dashboard.</p>
-            </div>
-        </div>
-
-    );
+    return null;
 };
 
 export default Dashboard;

package/templates/app.module.template.js

@@ -1,27 +1,39 @@
-import {
-    MiddlewareConsumer, Module, NestModule, RequestMethod,
-} from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
-import { ConfigModule } from '@nestjs/config';
-import {AuthModule, PrismaInterceptor, AppxCoreModule} from '@appxdigital/appx-core';
-import { APP_INTERCEPTOR } from '@nestjs/core';
-import {
-    RequestContextModule, RequestContextMiddleware,
-} from 'nestjs-request-context'
-import { PermissionsConfig } from './config/permissions.config';
+import {MiddlewareConsumer, Module, NestModule, RequestMethod} from '@nestjs/common';
+import {AppController} from './app.controller';
+import {AppService} from './app.service';
+import {ConfigModule} from '@nestjs/config';
+import {AuthModule, PrismaInterceptor, AppxCoreModule, AppxCoreAdminModule} from '@appxdigital/appx-core';
+import {APP_INTERCEPTOR} from '@nestjs/core';
+import {RequestContextModule, RequestContextMiddleware} from 'nestjs-request-context'
+import {PermissionsConfig} from './config/permissions.config';
+import {AdminConfig} from './config/admin.config';
 
 @Module({
-    imports: [RequestContextModule, ConfigModule.forRoot({
-        isGlobal: true, expandVariables: true, envFilePath: `.env.${process.env.NODE_ENV || 'development'}`,
-    }), AppxCoreModule.forRoot(PermissionsConfig), RequestContextModule, AuthModule,], controllers: [AppController], providers: [AppService, {
-        provide: APP_INTERCEPTOR, useClass: PrismaInterceptor,
-    },],
+    imports: [
+        RequestContextModule,
+        ConfigModule.forRoot({
+            isGlobal: true,
+            expandVariables: true,
+            envFilePath: `.env.${process.env.NODE_ENV || 'development'}`,
+        }),
+        AppxCoreModule.forRoot(PermissionsConfig),
+        AppxCoreAdminModule.forRoot(AdminConfig, PermissionsConfig),
+        RequestContextModule,
+        AuthModule,
+    ],
+    controllers: [AppController],
+    providers: [
+        AppService,
+        {
+            provide: APP_INTERCEPTOR,
+            useClass: PrismaInterceptor,
+        },
+    ],
 })
 export class AppModule implements NestModule {
-    configure(consumer: MiddlewareConsumer) {
+    configure (consumer: MiddlewareConsumer) {
         consumer
             .apply(RequestContextMiddleware)
-            .forRoutes({ path: '*', method: RequestMethod.ALL });
+            .forRoutes({path: '*', method: RequestMethod.ALL});
     }
 }

package/templates/permissions.config.template.js

@@ -1,17 +1,20 @@
-import {PermissionsConfigType} from '@appxdigital/appx-core';
+import {
+    PermissionsConfigType,
+    PermissionPlaceholder,
+} from '@appxdigital/appx-core';
 
 export const PermissionsConfig: PermissionsConfigType = {
     User: {
         ADMIN: {
-            findUnique: 'ALL',
+            findFirst: 'ALL',
             findMany: 'ALL',
             create: 'ALL',
-            update: 'ALL',
-            delete: 'ALL',
+            updateMany: 'ALL',
+            deleteMany: 'ALL',
         },
         CLIENT: {
-            findUnique: {
-                conditions: { id: '$USER_ID' }
+            findFirst: {
+                conditions: { id: PermissionPlaceholder.USER_ID },
             },
         }
     },

package/wizard.js

@@ -225,12 +225,19 @@ APP_PORT=3000
 
 #Default behaviour for use of transactions
 USE_TRANSACTION=true
+
 #Session secret
-SESSION_SECRET="DEFAULT_SECRET"
+SESSION_SECRET="${require('crypto').randomBytes(32).toString('hex')}"
+
 #Cookie name for the session token
 SESSION_COOKIE_NAME="APPXCORE"
+
 #Expiration time for the session token in seconds
 SESSION_TTL=86400
+
+# JWT
+JWT_SECRET="${require('crypto').randomBytes(32).toString('hex')}"
+JWT_REFRESH_SECRET="${require('crypto').randomBytes(32).toString('hex')}"
 `;
 
         fs.writeFileSync(`${projectPath}/.env`, envContent);
@@ -262,9 +269,6 @@ SESSION_TTL=86400
 }
 
 function setupProjectStructure(projectPath, answers) {
-
-    const includeBackoffice = answers?.backoffice;
-
     ensureAndRunNestCli(projectPath, answers?.showOutput);
     incrementProgress(answers?.showOutput, "nestjs");
 
@@ -288,7 +292,7 @@ function setupProjectStructure(projectPath, answers) {
         console.warn('Could not find generated tsconfig.json to modify.');
     }
 
-    const appModuleContent = includeBackoffice ? getAdminAppModuleTemplate() : getAppModuleTemplate();
+    const appModuleContent = getAppModuleTemplate();
     fs.writeFileSync(`${projectPath}/src/app.module.ts`, appModuleContent);
     incrementProgress(answers?.showOutput, "appmodule");
     installDependenciesFromManifest(answers?.showOutput);
@@ -314,7 +318,7 @@ function setupProjectStructure(projectPath, answers) {
     addScriptsToPackageJson(projectPath);
 
     if (includeBackoffice) {
-        executeCommand('npm install adminjs @adminjs/express @adminjs/nestjs @adminjs/prisma @prisma/sdk react express-formidable @adminjs/passwords', answers?.showOutput);
+        executeCommand('npm install adminjs @adminjs/express @adminjs/import-export @adminjs/nestjs @adminjs/prisma @prisma/sdk react express-formidable @adminjs/passwords', answers?.showOutput);
         setupAdminJS(projectPath);
         incrementProgress(answers?.showOutput, "adminSetup");
     }
@@ -397,11 +401,6 @@ function getAdminTemplate() {
     return fs.readFileSync(template, 'utf8');
 }
 
-function getAdminAppModuleTemplate() {
-    const appModuleTemplatePath = path.join(__dirname, 'templates', 'adminjs', 'adminjs-app.module.template.js');
-    return fs.readFileSync(appModuleTemplatePath, 'utf8');
-}
-
 function createPermissionsConfig(projectPath) {
     const configDir = path.join(projectPath, 'src/config');
     fs.ensureDirSync(configDir);
@@ -412,6 +411,16 @@ function createPermissionsConfig(projectPath) {
     fs.writeFileSync(path.join(configDir, 'permissions.config.ts'), permissionsConfigContent);
 }
 
+function createAdminConfig(projectPath) {
+    const configDir = path.join(projectPath, 'src/config');
+    fs.ensureDirSync(configDir);
+
+    const templatePath = path.join(__dirname, 'templates', 'admin.config.template.js');
+    const permissionsConfigContent = fs.readFileSync(templatePath, 'utf-8');
+
+    fs.writeFileSync(path.join(configDir, 'admin.config.ts'), permissionsConfigContent);
+}
+
 function customizePrismaSchema(projectPath, answers) {
     const prismaDir = `${projectPath}/prisma`;
     const schemaFile = `${prismaDir}/schema.prisma`;

package/templates/adminjs/admin.template.js

@@ -1,143 +0,0 @@
-import { DynamicModule } from '@nestjs/common';
-import { addBasicFilters, createActions, createPermissionHandler, dynamicImport, getAdminJSResources } from './utils';
-import { initializeComponents } from './component-loader';
-import { readFileSync } from 'fs';
-import { getDMMF } from '@prisma/sdk';
-import {PrismaService} from '@appxdigital/appx-core';
-import { PrismaModule } from "../prisma/prisma.module";
-
-const DEFAULT_ADMIN = {
-    email: 'joao.duvido@appx.pt',
-    password: 'password',
-};
-
-const authenticate = async (email: string, password: string) => {
-    if (email === DEFAULT_ADMIN.email && password === DEFAULT_ADMIN.password) {
-        return Promise.resolve(DEFAULT_ADMIN);
-    }
-    return null;
-};
-
-export async function createAdminJsModule(): Promise<DynamicModule> {
-    // Due to AdminJS only allowing ESM now, we need to use dynamic imports to load the modules, this function can be found within src/backoffice/utils.ts
-    const { default: AdminJS } = await dynamicImport('adminjs');
-    const { Database, Resource } = await dynamicImport('@adminjs/prisma');
-    const { AdminModule } = await dynamicImport('@adminjs/nestjs');
-    const { default: importExportFeature } = await dynamicImport('@adminjs/import-export');
-    const { default: passwordFeature } = await dynamicImport('@adminjs/passwords');
-    const argon2 = await dynamicImport('argon2');
-
-    // Below, this function in src/backoffice/utils.ts is used to get the resources you want to expose to AdminJS
-    const resources = getAdminJSResources();
-
-    // Once you create customized components, you can load them on the componentLoader just like the Dashboard component example
-
-    const { componentLoader, Components } = await initializeComponents();
-
-    // This gets the models from the Prisma schema, and then creates the AdminJS resources
-    const schemaPath = './prisma/schema.prisma';
-    const schema = readFileSync(schemaPath, 'utf-8');
-    const dmmf = await getDMMF({ datamodel: schema });
-
-    const models = [];
-
-    for (const resource of resources) {
-        const model = dmmf.datamodel.models.find(
-            (model) => model.name === resource.name,
-        );
-
-        models.push({
-            model,
-            options: resource.options,
-            features: model.name === 'User' ? [
-                passwordFeature({
-                    properties: {
-                        encryptedPassword: 'password',
-                        password: 'plainPassword',
-                    },
-                    hash: argon2.hash,
-                    componentLoader,
-                }),
-            ] : [],
-        });
-    }
-
-    AdminJS.registerAdapter({ Database, Resource });
-
-
-    return AdminModule.createAdminAsync({
-        imports: [PrismaModule],
-        inject: [PrismaService],
-        useFactory: async (prisma: PrismaService) => {
-
-            // If you comment out this function below, you will be able to access the AdminJS with the DEFAULT_ADMIN credentials at the top of this file
-            // With that, you can create a new user, and then undo the comment on this function to disable the default admin, using the new user you created
-            const authenticate = async (email: string, password: string) => {
-                const user = await prisma.user.findUnique({
-                    where: {
-                        email
-                    }
-                });
-
-                if (!user || user.role !== 'ADMIN') {
-                    return null;
-                }
-
-                const isPasswordValid = await argon2.verify(user.password, password);
-
-                return isPasswordValid ? Promise.resolve({ email: user.email, role: user.role, id: user.id }) : null;
-            }
-
-            return {
-                adminJsOptions: {
-                    rootPath: '/admin',
-                    // As you can see below, you can customize the dashboard component, which is the first page you see when you access the AdminJS
-                    dashboard: {
-                        component: Components.Dashboard,
-                        handler: async () => {
-                            return { some: 'output' };
-                        },
-                    },
-                    branding: {
-                        // Here you can change the company name, which appears on the browser's tab
-                        companyName: 'AppX Core Wizard',
-                        // This removes the "Made with love (...)" from the footer
-                        withMadeWithLove: false,
-                        // Here you can change the logo, currently using AppX's as an example
-                        logo: 'https://i.ibb.co/XZNRS5m/appxdigitalcom-logo.jpg',
-                    },
-                    resources: models.map((m) => {
-                        return {
-                            resource: { model: m.model, client: prisma },
-                            options: {
-                                ...m.options,
-                                actions: createActions(),
-                            },
-                            features: [...(m.features || []), importExportFeature({
-                                componentLoader
-                            })],
-                        };
-                    }),
-
-                    componentLoader,
-                },
-                auth: {
-                    authenticate,
-                    cookieName: process.env.SESSION_COOKIE_NAME,
-                    cookiePassword: process.env.SESSION_SECRET,
-                },
-                sessionOptions: {
-                    resave: false,
-                    saveUninitialized: true,
-                    secret: process.env.SESSION_SECRET,
-                    cookie: {
-                        httpOnly: process.env.NODE_ENV === 'production',
-                        //secure: process.env.NODE_ENV === 'production',
-                        secure: false,
-                    },
-                    name: process.env.SESSION_COOKIE_NAME,
-                },
-            };
-        },
-    });
-}

package/templates/adminjs/adminjs-app.module.template.js

@@ -1,48 +0,0 @@
-import {
-    MiddlewareConsumer,
-    Module,
-    NestModule,
-    RequestMethod,
-} from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
-import { APP_INTERCEPTOR } from '@nestjs/core';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
-import {AppxCoreModule, AuthModule, PrismaInterceptor} from '@appxdigital/appx-core';
-import {
-    RequestContextModule,
-    RequestContextMiddleware,
-} from 'nestjs-request-context';
-import { UserModule } from './modules/user/user.module';
-import { PermissionsConfig } from "./config/permissions.config";
-import { createAdminJsModule } from "./backoffice/admin";
-
-@Module({
-    imports: [
-        RequestContextModule,
-        ConfigModule.forRoot({
-            isGlobal: true,
-            expandVariables: true,
-            envFilePath: `.env.${process.env.NODE_ENV || 'development'}`,
-        }),
-        AppxCoreModule.forRoot(PermissionsConfig),
-        AuthModule,
-        UserModule,
-        createAdminJsModule().then((AdminJsModule) => AdminJsModule),
-    ],
-    controllers: [AppController],
-    providers: [
-        AppService,
-        {
-            provide: APP_INTERCEPTOR,
-            useClass: PrismaInterceptor,
-        },
-    ],
-})
-export class AppModule implements NestModule {
-    configure(consumer: MiddlewareConsumer) {
-        consumer
-            .apply(RequestContextMiddleware)
-            .forRoutes({ path: '*', method: RequestMethod.ALL });
-    }
-}

package/templates/adminjs/component-loader.template.js

@@ -1,14 +0,0 @@
-import { dynamicImport } from "./utils";
-
-async function loadComponents() {
-    const { ComponentLoader } = await dynamicImport('adminjs');
-    const componentLoader = new ComponentLoader();
-
-    const Components = {
-        Dashboard: componentLoader.add('dashboard', './components/dashboard'),
-    };
-
-    return { componentLoader, Components };
-}
-
-export const initializeComponents = loadComponents;

package/templates/adminjs/utils.template.js

@@ -1,131 +0,0 @@
-import { PermissionsConfig } from "../config/permissions.config";
-
-export const dynamicImport = async (packageName: string) =>
-    new Function(`return import('${packageName}')`)();
-
-export const getAdminJSResources = (specific = null) => {
-    const resources = [
-        {
-            name: 'User',
-            options: {},
-        },
-    ];
-
-    return specific ? resources.filter((r) => r.name === specific) : resources;
-};
-
-export function createPermissionHandler(role: string, resource: string, action: string) {
-    const rolePermissions = PermissionsConfig[resource]?.[role];
-
-    if (!rolePermissions) {
-        return () => false;
-    }
-
-    const actionMapping = {
-        list: 'findMany',
-        show: 'findUnique',
-        edit: 'update',
-        delete: 'delete',
-        new: 'create',
-    };
-
-    const mappedAction = actionMapping[action];
-
-    if (!mappedAction || !rolePermissions[mappedAction]) {
-        return () => false;
-    }
-
-    if (rolePermissions[mappedAction] === 'ALL') {
-        return () => true;
-    }
-
-    if (typeof rolePermissions[mappedAction] === 'object') {
-
-        return (requestContext) => {
-            // @ts-ignore
-            const clauses = rolePermissions[mappedAction]?.clauses;
-            if (!clauses) return () => false;
-            return parseClauses(clauses)(requestContext);
-        };
-    }
-
-    return () => false;
-}
-
-const clauseMapping = {
-    '$USER_ID': "id",
-    '$USER_EMAIL': "email",
-};
-
-const parseClauses = (clauses) => {
-    return (requestContext) => {
-        if (!clauses || !Array.isArray(clauses)) return true;
-
-        for (const clause of clauses) {
-            if (clause.type === 'field') {
-                for (const [field, value] of Object.entries(clause.conditions)) {
-                    let actualValue = value;
-
-                    if (typeof value === 'string' && value.startsWith('$')) {
-                        actualValue = requestContext?.currentAdmin[clauseMapping[value]] ?? null;
-                    }
-
-                    if (requestContext.record?.param(field) !== actualValue) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    };
-};
-
-
-export const addBasicFilters = (filters) => {
-    return async (request, context) => {
-        for (const [field, value] of Object.entries(filters)) {
-            request.query[`filters.${field}`] = value;
-        }
-        return request;
-    };
-};
-
-export const createActions = () => {
-    return {
-        list: {
-            isAccessible: createIsAccessible('list'),
-        },
-        show: {
-            isAccessible: createIsAccessible('show'),
-        },
-        edit: {
-            isAccessible: createIsAccessible('edit'),
-        },
-        delete: {
-            isAccessible: createIsAccessible('delete'),
-        },
-        new: {
-            isAccessible: createIsAccessible('new'),
-        },
-    };
-};
-
-const createIsAccessible = (action) => {
-    return (context) => {
-        if (!context.currentAdmin) return false;
-        const { role } = context.currentAdmin;
-        return createPermissionHandler(role, context.resource.model.name, action)(context);
-    };
-};
-
-const createBeforeHook = (filters) => {
-    return (request, context) => {
-        if (context.currentAdmin) {
-            request.query.filters = {
-                ...request.query.filters,
-                ...filters,
-            };
-        }
-        return request;
-    };
-};