@appxdigital/appx-core 0.1.68

package/dist/config/generate-modules.js

@@ -0,0 +1,158 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+const modelsPath = path.join(process.cwd(), 'src/generated');
+const modulesOutputPath = path.join(process.cwd(), 'src/modules');
+const appModulePath = path.join(process.cwd(), 'src/app.module.ts');
+/**
+ * Generic module template for a given model
+ * @param model
+ * @param folder
+ */
+const moduleTemplate = (model, folder) => `
+import { Module } from '@nestjs/common';
+import { PrismaModule } from '../../prisma/prisma.module';
+import { ${model}Controller } from './${folder}.controller';
+import { ${model}Service } from './${folder}.service';
+import { ${model}Resolver } from './${folder}.resolver';
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [${model}Controller],
+  providers: [${model}Service, ${model}Resolver],
+})
+export class ${model}Module {}
+`;
+/**
+ * Create or update the module file for a given model
+ * @param model
+ * @param modulePath
+ * @param folder
+ */
+const createModuleFile = (model, modulePath, folder) => {
+    const moduleContent = moduleTemplate(model, folder);
+    fs.writeFileSync(modulePath, moduleContent);
+    console.log(`Module for ${model} created or updated.`);
+};
+/**
+ * Update the AppModule with new module imports
+ */
+const updateAppModule = () => {
+    let appModuleContent = fs.readFileSync(appModulePath, 'utf8');
+    /**
+     * Regex to extract existing module imports from the AppModule
+     */
+    const importRegex = /import { (\w+)Module } from '.\/modules\/\w+\/\w+.module';/g;
+    const existingImports = new Set();
+    let match;
+    while ((match = importRegex.exec(appModuleContent)) !== null) {
+        existingImports.add(match[1]);
+    }
+    const newImports = [];
+    const newModules = [];
+    /**
+     * Regex to extract the imports array from the AppModule to prevent duplicates
+     */
+    const importsArrayRegex = /(imports:\s*\[)([^]*?)(\])/;
+    const importsArrayMatch = appModuleContent.match(importsArrayRegex);
+    const existingModuleNames = new Set();
+    if (importsArrayMatch) {
+        const currentImportsArray = importsArrayMatch[2]
+            .split(',')
+            .map((m) => m.trim().replace(/\s/g, ''))
+            .filter((m) => m);
+        currentImportsArray.forEach((moduleName) => {
+            existingModuleNames.add(moduleName);
+        });
+    }
+    /**
+     * Iterate over the modules directory and add new imports to the AppModule
+     */
+    fs.readdirSync(modulesOutputPath).forEach((folder) => {
+        if (folder === 'prisma' || folder === 'schema.gql' || folder === 'session')
+            return;
+        const modelName = (0, utils_1.kebabToPascalCase)(folder);
+        const moduleName = `${modelName}Module`;
+        // Ensure no duplicate imports and no duplicate entries in the imports array
+        if (!existingImports.has(moduleName) && !existingModuleNames.has(moduleName)) {
+            newImports.push(`import { ${modelName}Module } from './modules/${folder}/${folder}.module';`);
+            newModules.push(moduleName);
+        }
+    });
+    if (newImports.length === 0) {
+        console.log('No new modules to add.');
+        return;
+    }
+    // Add new imports to AppModule and update the imports array without duplicates
+    appModuleContent = appModuleContent.replace(/(imports:\s*\[)([^]*?)(\])/, (_, prefix, currentImports, suffix) => {
+        const currentModules = currentImports
+            .split(',')
+            .map((m) => m.trim())
+            .filter((m) => m);
+        newModules.forEach((newModule) => {
+            if (!currentModules.includes(newModule)) {
+                currentModules.push(newModule);
+            }
+        });
+        return `${prefix}${currentModules.join(', ')}${suffix}`;
+    });
+    const finalContent = newImports.join('\n') + '\n' + appModuleContent;
+    fs.writeFileSync(appModulePath, finalContent);
+    console.log('AppModule updated successfully.');
+};
+/**
+ * Generate modules for each model
+ */
+fs.readdirSync(modelsPath).forEach((folder) => {
+    if (folder === 'prisma' || folder === 'schema.gql' || folder === 'session')
+        return;
+    const modelName = (0, utils_1.kebabToPascalCase)(folder);
+    const modelOutputPath = path.join(modulesOutputPath, folder);
+    if (!fs.existsSync(modelOutputPath)) {
+        fs.mkdirSync(modelOutputPath, { recursive: true });
+        console.log(`Folder for model ${modelName} created.`);
+    }
+    const modulePath = path.join(modelOutputPath, `${folder}.module.ts`);
+    if (!fs.existsSync(modulePath)) {
+        createModuleFile(modelName, modulePath, folder);
+    }
+    else {
+        console.log(`Module for ${modelName} already exists, skipping.`);
+    }
+});
+updateAppModule();

package/dist/config/generate-resolvers.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-resolvers.d.ts.map

package/dist/config/generate-resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-resolvers.d.ts","sourceRoot":"","sources":["../../src/config/generate-resolvers.ts"],"names":[],"mappings":""}

package/dist/config/generate-resolvers.js

@@ -0,0 +1,97 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+const modelsPath = path.join(process.cwd(), 'src/generated');
+const outputPath = path.join(process.cwd(), 'src/modules');
+/**
+ * Generic resolver template for a given model
+ * @param model
+ * @param folder
+ */
+const genericResolverTemplate = (model, folder) => `import { Resolver } from '@nestjs/graphql';
+import { GenericResolverFactory, PrismaService } from 'appx-core';
+import { ${model} } from '../../generated/${folder}/${folder}.model';
+import { ${model}CreateInput } from '../../generated/${folder}/${folder}-create.input';
+import { ${model}UpdateInput } from '../../generated/${folder}/${folder}-update.input';
+import { ${model}WhereInput } from '../../generated/${folder}/${folder}-where.input';
+import { ${model}WhereUniqueInput } from '../../generated/${folder}/${folder}-where-unique.input';
+import { FindMany${model}Args } from '../../generated/${folder}/find-many-${folder}.args';
+import { ${model}AggregateArgs } from '../../generated/${folder}/${folder}-aggregate.args';
+import { Aggregate${model} } from '../../generated/${folder}/aggregate-${folder}.output';
+import { CreateMany${model}Args } from '../../generated/${folder}/create-many-${folder}.args';
+import { ${model}CreateManyInput } from '../../generated/${folder}/${folder}-create-many.input';
+
+const ${model}GenericResolver = GenericResolverFactory(
+  '${model}',
+  ${model},
+  ${model}CreateInput,
+  ${model}UpdateInput,
+  ${model}WhereInput,
+  ${model}WhereUniqueInput,
+  FindMany${model}Args,
+  ${model}AggregateArgs,
+  Aggregate${model},
+  CreateMany${model}Args,
+  ${model}CreateManyInput,
+);
+
+@Resolver(() => ${model})
+export class ${model}Resolver extends ${model}GenericResolver {
+  constructor(prisma: PrismaService) {
+    super(prisma);
+  }
+}
+`;
+/**
+ * Generate resolvers for each model
+ */
+fs.readdirSync(modelsPath).forEach((folder) => {
+    if (folder === 'prisma' || folder === 'schema.gql' || folder === 'session')
+        return;
+    const modelName = (0, utils_1.kebabToPascalCase)(folder);
+    const modelOutputPath = path.join(outputPath, folder);
+    if (!fs.existsSync(modelOutputPath)) {
+        fs.mkdirSync(modelOutputPath, { recursive: true });
+        console.log(`Folder for model ${modelName} created.`);
+    }
+    else {
+        console.log(`Folder for model ${modelName} already exists, skipping creation.`);
+    }
+    const resolverPath = path.join(modelOutputPath, `${folder}.resolver.ts`);
+    (0, utils_1.createFileIfNotExists)(resolverPath, genericResolverTemplate(modelName, folder));
+});

package/dist/config/generate-services.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-services.d.ts.map

package/dist/config/generate-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-services.d.ts","sourceRoot":"","sources":["../../src/config/generate-services.ts"],"names":[],"mappings":""}

package/dist/config/generate-services.js

@@ -0,0 +1,72 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const utils_1 = require("./utils");
+const modelsPath = path.join(process.cwd(), 'src/generated');
+const servicesOutputPath = path.join(process.cwd(), 'src/modules');
+/**
+ * Generic service template for a given model
+ * @param model
+ */
+const genericServiceTemplate = (model) => `import { Injectable } from '@nestjs/common';
+import { CoreService, PrismaService } from 'appx-core';
+import { ${model} } from '@prisma/client';
+
+@Injectable()
+export class ${model}Service extends CoreService<${model}> {
+  constructor(prisma: PrismaService) {
+    super(prisma.model.${model[0].toLowerCase() + model.slice(1)});
+  }
+
+  // Override methods or add custom logic as needed
+}
+`;
+/**
+ * Generate services for each model
+ */
+fs.readdirSync(modelsPath).forEach((folder) => {
+    if (folder === 'prisma' || folder === 'schema.gql' || folder === 'session')
+        return;
+    const modelName = (0, utils_1.kebabToPascalCase)(folder);
+    const modelOutputPath = path.join(servicesOutputPath, folder);
+    if (!fs.existsSync(modelOutputPath)) {
+        fs.mkdirSync(modelOutputPath, { recursive: true });
+        console.log(`Folder for model ${modelName} created.`);
+    }
+    const servicePath = path.join(modelOutputPath, `${folder}.service.ts`);
+    (0, utils_1.createFileIfNotExists)(servicePath, genericServiceTemplate(modelName));
+});

package/dist/config/generate-session-schema.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-session-schema.d.ts.map

package/dist/config/generate-session-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-session-schema.d.ts","sourceRoot":"","sources":["../../src/config/generate-session-schema.ts"],"names":[],"mappings":""}

package/dist/config/generate-session-schema.js

@@ -0,0 +1,78 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const schemaPath = path.join(process.cwd(), 'prisma/schema/schema.prisma');
+const sessionSchemaPath = path.join(process.cwd(), 'prisma/schema/session.prisma');
+/**
+ * Check if the "Session" model exists in schema.prisma
+ * @returns {boolean} - True if the Session model exists, otherwise false.
+ */
+const doesSessionModelExist = () => {
+    if (fs.existsSync(schemaPath)) {
+        const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+        const sessionModelRegex = /model\s+session\s*{[\s\S]*?}/i;
+        return sessionModelRegex.test(schemaContent);
+    }
+    return false;
+};
+/**
+ * Ensure that the session schema exists if it is not already defined in schema.prisma
+ */
+const ensureSessionSchemaExists = () => {
+    if (doesSessionModelExist()) {
+        console.log('Session model already exists in schema.prisma. Skipping creation of session.prisma.');
+        return;
+    }
+    if (!fs.existsSync(sessionSchemaPath)) {
+        console.log('Session schema not found in session.prisma. Creating it...');
+        const sessionSchemaContent = `
+      model Session {
+        id        String   @id
+        sid       String   @unique
+        data      String
+        expiresAt DateTime
+        userId    Int?
+      }
+    `;
+        fs.writeFileSync(sessionSchemaPath, sessionSchemaContent);
+        console.log('Session schema created successfully in session.prisma.');
+    }
+    else {
+        console.log('Session schema already exists in session.prisma.');
+    }
+};
+ensureSessionSchemaExists();

package/dist/config/setup-fileupload.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=setup-fileupload.d.ts.map

package/dist/config/setup-fileupload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-fileupload.d.ts","sourceRoot":"","sources":["../../src/config/setup-fileupload.ts"],"names":[],"mappings":""}