nebula-starter-kit 0.0.1

package/dist/utils/generateFiles.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNextJSEnv = exports.generateRootEnv = exports.generateServerlessFiles = exports.generateInfraCognitoFile = exports.generateInfraBucketFile = exports.generateInfraApiFile = exports.generateNebulaJson = exports.generateRootLambda = void 0;
+const fs = require('fs-extra');
+const path = require('path');
+const addService_1 = require("./addService");
+const replaceServiceNames_1 = require("./replaceServiceNames");
+const telemetryAddon_1 = require("./telemetryAddon");
+const region = (0, telemetryAddon_1.getAwsRegion)();
+const generateRootLambda = (apiName = 'API', services = [], directory) => {
+    console.log(services, apiName);
+    apiName = apiName.charAt(0).toUpperCase() + apiName.slice(1);
+    const fileContent = `export const handler = async () => {
+
+  const services = ${JSON.stringify(services)};
+
+  return {
+    statusCode: 200,
+    headers: {
+      "Content-Type": "application/json",
+      'Access-Control-Allow-Origin': '*',  // match your cors config
+      'Access-Control-Allow-Headers': 'Content-Type,Authorization',
+      'Access-Control-Allow-Methods': 'OPTIONS,POST,GET,PUT,DELETE',
+    },
+    body: JSON.stringify({
+      name: "${apiName} API",
+      services,
+      message: "Welcome to the ${apiName} API"
+    })
+  }
+}
+`;
+    const outputPath = path.join(directory, 'infra/api/src/root.ts');
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, fileContent);
+    console.log('✅ Root API lambda generated from nebula.json');
+};
+exports.generateRootLambda = generateRootLambda;
+const generateNebulaJson = (appName, selectedServices, OUTPUT) => {
+    const nebulaConfig = {
+        name: appName,
+        runtime: 'nestjs',
+        architecture: 'multi-lambda',
+        deployment: 'serverless-compose',
+        services: selectedServices,
+        region,
+    };
+    fs.writeJsonSync(path.join(OUTPUT, 'nebula.json'), nebulaConfig, {
+        spaces: 2,
+    });
+};
+exports.generateNebulaJson = generateNebulaJson;
+const generateInfraApiFile = async (appName, OUTPUT) => {
+    const infraDir = path.join(OUTPUT, 'infra/api');
+    await fs.ensureDir(infraDir);
+    const infraServerlessTemplate = `service: ${appName}-shared-api
+  
+provider:
+  name: aws
+  runtime: nodejs20.x
+  stage: \${opt:stage, 'dev'}
+  region: ${region}
+
+functions:
+  root:
+    handler: src/root.handler
+    events:
+      - http:
+          path: /
+          method: get
+          cors: true
+          
+resources:
+  Resources:
+    ApiGatewayRestApi:
+      Type: AWS::ApiGateway::RestApi
+      Properties:
+        Name: ${appName}-shared-api
+
+  Outputs:
+    ApiGatewayRestApiId:
+      Value: !Ref ApiGatewayRestApi
+
+    ApiGatewayRootResourceId:
+      Value: !GetAtt ApiGatewayRestApi.RootResourceId
+  `;
+    await fs.writeFile(path.join(infraDir, 'serverless.yml'), infraServerlessTemplate);
+};
+exports.generateInfraApiFile = generateInfraApiFile;
+const generateInfraBucketFile = async (appName, OUTPUT) => {
+    const bucketDir = path.join(OUTPUT, 'infra/buckets');
+    await fs.ensureDir(bucketDir);
+    const bucketServerlessTemplate = `service: ${appName}-buckets
+  
+plugins:
+  - serverless-s3-sync
+
+custom:
+#  cloudfrontDistributionId: E2OW0GLR4XXOBS
+#  scripts:
+#    hooks:
+#      after:deploy:deploy: >
+#        aws cloudfront create-invalidation
+#        --distribution-id \${self:custom.cloudfrontDistributionId}
+#        --paths "/*"
+  # scripts:
+  #   hooks:
+  #     # Run BEFORE upload to S3
+  #     before:deploy:deploy: node scripts/generate-env.js
+
+  s3Sync:
+    - bucketName: ${appName}-bucket-\${aws:accountId}-\${self:provider.stage}
+      localDir: ../../ui/out
+      deleteRemoved: true
+
+params:
+  dev:
+    region: ${region}
+    disableLogs: true
+    # publicCloudfrontSubdomain: "${appName}.nebulalogix.io"
+
+provider:
+  name: aws
+  stage: \${opt:stage, 'dev'}
+  region: ${region}
+  environment:
+    DEPLOYMENT_TIME: \${sls:instanceId}
+
+resources:
+  Resources:
+    S3WebsiteBucket:
+      Type: AWS::S3::Bucket
+      Properties:
+        BucketName: ${appName}-bucket-\${aws:accountId}-\${self:provider.stage}
+        WebsiteConfiguration:
+          IndexDocument: index.html
+          ErrorDocument: index.html
+        PublicAccessBlockConfiguration:
+          BlockPublicAcls: false
+          IgnorePublicAcls: false
+          BlockPublicPolicy: false
+          RestrictPublicBuckets: false
+
+    S3BucketPolicy:
+      Type: AWS::S3::BucketPolicy
+      Properties:
+        Bucket: !Ref S3WebsiteBucket
+        PolicyDocument:
+          Version: "2012-10-17"
+          Statement:
+            - Effect: Allow
+              Principal: "*"
+              Action:
+                - s3:GetObject
+              Resource: !Sub "\${S3WebsiteBucket.Arn}/*"
+
+            # Allow your AWS account to deploy files
+            - Effect: Allow
+              Principal:
+                AWS: !Sub "arn:aws:iam::\${AWS::AccountId}:root"
+              Action:
+                - s3:PutObject
+                - s3:DeleteObject
+                - s3:ListBucket
+              Resource:
+                - !Sub "\${S3WebsiteBucket.Arn}"
+                - !Sub "\${S3WebsiteBucket.Arn}/*"
+  
+  
+  Outputs:
+    WebsiteURL:
+      Value: !GetAtt S3WebsiteBucket.WebsiteURL
+      Description: Public website URL
+  `;
+    await fs.writeFile(path.join(bucketDir, 'serverless.yml'), bucketServerlessTemplate);
+};
+exports.generateInfraBucketFile = generateInfraBucketFile;
+const generateInfraCognitoFile = async (appName, OUTPUT) => {
+    const cognitoDir = path.join(OUTPUT, 'infra/cognito');
+    await fs.ensureDir(cognitoDir);
+    const cognitoServerlessTemplate = `service: ${appName}-cognito
+  
+provider:
+  name: aws
+  runtime: nodejs20.x
+  stage: \${opt:stage, 'dev'}
+  region: us-east-1
+
+resources:
+  Resources:
+# Cognito User Pool
+    UserPool:
+      Type: AWS::Cognito::UserPool
+      Properties:
+        UserPoolName: ${appName}-userpool
+        AutoVerifiedAttributes:
+          - email
+        UsernameAttributes:
+          - email
+        Policies:
+          PasswordPolicy:
+            MinimumLength: 8
+            RequireLowercase: true
+            RequireUppercase: true
+            RequireNumbers: true
+
+    # Cognito User Pool Client
+    UserPoolClient:
+      Type: AWS::Cognito::UserPoolClient
+      Properties:
+        ClientName: ${appName}-userpoolclient
+        UserPoolId: !Ref UserPool
+        ExplicitAuthFlows:
+          - ALLOW_USER_PASSWORD_AUTH
+          - ALLOW_REFRESH_TOKEN_AUTH
+        GenerateSecret: false
+
+    # Cognito User Pool Domain
+    UserPoolDomain:
+      Type: AWS::Cognito::UserPoolDomain
+      Properties:
+        Domain: ${appName}-userpooldomain
+        UserPoolId: !Ref UserPool
+
+    # 4️⃣ Lambda Role with Cognito permissions
+    LambdaCognitoRole:
+      Type: AWS::IAM::Role
+      Properties:
+        RoleName: ${appName}-lambda-cognito-role-\${self:provider.stage}
+        AssumeRolePolicyDocument:
+          Version: '2012-10-17'
+          Statement:
+            - Effect: Allow
+              Principal:
+                Service:
+                  - lambda.amazonaws.com
+              Action:
+                - sts:AssumeRole
+        Policies:
+          - PolicyName: CognitoAccessPolicy
+            PolicyDocument:
+              Version: '2012-10-17'
+              Statement:
+                - Effect: Allow
+                  Action:
+                    - cognito-idp:AdminCreateUser
+                    - cognito-idp:AdminDeleteUser
+                    - cognito-idp:AdminGetUser
+                    - cognito-idp:AdminUpdateUserAttributes
+                    - cognito-idp:ListUsers
+                    - cognito-idp:AdminInitiateAuth
+                  Resource: !GetAtt UserPool.Arn
+
+  Outputs:
+    # Export the User Pool ID
+    CognitoUserPoolId:
+      Value: !Ref UserPool
+
+    # Export the User Pool Client ID
+    CognitoClientId:
+      Value: !Ref UserPoolClient
+
+    # Export the User Pool Domain
+    CognitoUserPoolDomain:
+      Value: !Ref UserPoolDomain
+  `;
+    await fs.writeFile(path.join(cognitoDir, 'serverless.yml'), cognitoServerlessTemplate);
+};
+exports.generateInfraCognitoFile = generateInfraCognitoFile;
+const generateServerlessFiles = async (selectedServices, ROOT, OUTPUT, appNamePlaceHolder) => {
+    for (const service of selectedServices) {
+        const serviceOutput = path.join(OUTPUT, 'services', service);
+        await fs.ensureDir(serviceOutput);
+        // copy base nest template
+        fs.copySync(path.join(ROOT, 'templates/service'), serviceOutput);
+        // update service names
+        await (0, replaceServiceNames_1.replaceServiceNames)(serviceOutput, service, appNamePlaceHolder);
+        console.log(`✅ Service ${service} created\n`);
+        // Generate serverless.yml per service
+        await fs.writeFile(path.join(serviceOutput, 'serverless.yml'), (0, addService_1.serverlessTemplate)(service, appNamePlaceHolder));
+        // Generate root serverless-compose.yml
+        let composeContent = `
+services:
+  api:
+    path: infra/api
+
+  cognito:
+    path: infra/cognito
+  
+  buckets:
+    path: infra/buckets
+`;
+        for (const service of selectedServices) {
+            composeContent += `
+  ${service}:
+    path: services/${service}
+    params:
+      ApiGatewayRestApiId: \${api.ApiGatewayRestApiId}
+      ApiGatewayRootResourceId: \${api.ApiGatewayRootResourceId}
+      CognitoClientId: \${cognito.CognitoClientId}
+      CognitoUserPoolId: \${cognito.CognitoUserPoolId}
+`;
+        }
+        await fs.writeFile(path.join(OUTPUT, 'serverless-compose.yml'), composeContent);
+    }
+};
+exports.generateServerlessFiles = generateServerlessFiles;
+const generateRootEnv = (OUTPUT) => {
+    const envRootContent = `COGNITO_USER_POOL_ID=
+COGNITO_CLIENT_ID=
+  `;
+    fs.writeFileSync(path.join(OUTPUT, '.env'), envRootContent.trim());
+    console.log('✅ Root env generated:');
+    console.log(envRootContent);
+};
+exports.generateRootEnv = generateRootEnv;
+const generateNextJSEnv = (appName, uiDir, selectedServices) => {
+    const envContent = `NEXT_PUBLIC_APP_NAME=${appName.charAt(0).toUpperCase() + appName.slice(1)}
+NEXT_PUBLIC_API_URL=
+NEXT_PUBLIC_SERVICES=${selectedServices.join(',')}
+  `;
+    fs.writeFileSync(path.join(uiDir, '.env.local'), envContent.trim());
+    console.log('✅ Next.js env generated:');
+    console.log(envContent);
+};
+exports.generateNextJSEnv = generateNextJSEnv;

package/dist/utils/generateSchemas.js

@@ -0,0 +1,58 @@
+"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 });
+exports.generateSchemas = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const generateSchemas = (OUTPUT) => {
+    const nebula = JSON.parse(fs.readFileSync(path.join(OUTPUT, 'nebula.json'), 'utf-8'));
+    let imports = '';
+    let exportsArr = [];
+    for (const service of nebula.services) {
+        const importName = `${service.toUpperCase()}_TABLE_SCHEMA`;
+        imports += `import { ${importName} } from "@services/${service}/src/${service}.schema";\n`;
+        exportsArr.push(importName);
+    }
+    const content = `
+${imports}
+
+export const GENERATED_SCHEMAS = [
+  ${exportsArr.join(',\n  ')}
+];
+`;
+    fs.writeFileSync(path.join(OUTPUT, 'core/database/generated-schemas.ts'), content);
+    console.log('✅ Schemas generated');
+};
+exports.generateSchemas = generateSchemas;

package/dist/utils/listServices.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listServices = listServices;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+function listServices() {
+    const ROOT = process.cwd();
+    const nebulaPath = path_1.default.join(ROOT, 'nebula.json');
+    if (!fs_extra_1.default.existsSync(nebulaPath)) {
+        throw new Error('Not a Nebula project');
+    }
+    const config = fs_extra_1.default.readJsonSync(nebulaPath);
+    if (config.services.length) {
+        console.log('Services:');
+        config.services.forEach((s) => console.log(`- ${s}`));
+        console.log('\n');
+    }
+    else {
+        console.log('No services present');
+    }
+}

package/dist/utils/replaceServiceNames.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceServiceNames = replaceServiceNames;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function replaceServiceNames(dir, service, appName) {
+    const name = service.toLowerCase();
+    const NAME = service.toUpperCase();
+    const Name = name.charAt(0).toUpperCase() + name.slice(1);
+    const files = await fs_extra_1.default.readdir(dir);
+    for (const file of files) {
+        const oldPath = path_1.default.join(dir, file);
+        const stat = await fs_extra_1.default.stat(oldPath);
+        if (stat.isDirectory()) {
+            await replaceServiceNames(oldPath, service, appName);
+        }
+        else {
+            // ✅ rename file if contains placeholder
+            const newFile = file
+                .replace(/__name__/g, name)
+                .replace(/__Name__/g, Name)
+                .replace(/__NAME__/g, NAME);
+            const newPath = path_1.default.join(dir, newFile);
+            if (newFile !== file) {
+                await fs_extra_1.default.rename(oldPath, newPath);
+            }
+            // ✅ replace content
+            let content = await fs_extra_1.default.readFile(newPath, 'utf8');
+            if (appName) {
+                content = content.replace(/__appName__/g, appName);
+            }
+            content = content
+                .replace(/__name__/g, name)
+                .replace(/__Name__/g, Name)
+                .replace(/__NAME__/g, NAME);
+            await fs_extra_1.default.writeFile(newPath, content);
+        }
+    }
+}

package/dist/utils/telemetryAddon.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnonymousId = getAnonymousId;
+exports.sendTelemetry = sendTelemetry;
+exports.promptTelemetry = promptTelemetry;
+exports.getAwsRegion = getAwsRegion;
+const https_1 = __importDefault(require("https"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const CONFIG_PATH = path_1.default.join(os_1.default.homedir(), '.nebula', 'config.json');
+async function getAnonymousId() {
+    if (await fs_extra_1.default.pathExists(CONFIG_PATH)) {
+        return (await fs_extra_1.default.readJson(CONFIG_PATH)).anonymousId;
+    }
+    const anonymousId = crypto.randomUUID();
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(CONFIG_PATH));
+    await fs_extra_1.default.writeJson(CONFIG_PATH, { anonymousId });
+    console.log('✅ Created anonymous ID for telemetry:', anonymousId);
+    return anonymousId;
+}
+function sendTelemetry(payload) {
+    const data = JSON.stringify(payload, null, 2);
+    console.log(`✅ Sending telemetry: ${data}`);
+    const req = https_1.default.request('https://telemetry.yourdomain.com/events', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': data.length,
+        },
+    });
+    req.on('error', () => { }); // NEVER crash CLI
+    req.write(data);
+    req.end();
+}
+async function promptTelemetry(appName, selectedServices) {
+    const { collectTelemetry } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'collectTelemetry',
+            message: 'Would you like to share anonymous usage data to improve NebulaLogix StarterKit?',
+            default: false,
+        },
+    ]);
+    const anonymousId = await getAnonymousId();
+    if (!collectTelemetry) {
+        sendTelemetry({
+            event: 'telemetry_opt_out',
+            timestamp: new Date().toISOString(),
+            anonymousId,
+        });
+        console.log('📊 Telemetry disabled');
+    }
+    else {
+        const systemPayload = {
+            cliVersion: package_json_1.default.version,
+            projectName: appName,
+            selectedServices,
+            anonymousId,
+            environment: {
+                os: os_1.default.platform(),
+                arch: os_1.default.arch(),
+                node: process.version,
+            },
+        };
+        sendTelemetry({
+            event: 'telemetry_opt_in',
+            timestamp: new Date().toISOString(),
+            ...systemPayload,
+        });
+        console.log('📊 Telemetry enabled. Thank you for helping us improve!');
+    }
+}
+function getAwsRegion() {
+    try {
+        const configPath = path_1.default.join(os_1.default.homedir(), '.aws', 'config');
+        if (!fs_extra_1.default.existsSync(configPath))
+            return null;
+        const content = fs_extra_1.default.readFileSync(configPath, 'utf8');
+        const match = content.match(/region\s*=\s*(.+)/);
+        return match ? match[1].trim() : null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "nebula-starter-kit",
+  "version": "0.0.1",
+  "bin": {
+    "nebula": "./dist/index.js"
+  },
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "ts-node ./src/index.ts",
+    "test": "jest",
+    "format": "prettier --write \"../**/*.ts\""
+  },
+  "files": ["dist", "templates"],
+  "dependencies": {
+    "fs-extra": "^11.1.0",
+    "inquirer": "^9.0.0",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "jest": "^30.3.0",
+    "prettier": "^2.3.2",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/templates/core/audit/audit.controller.ts

@@ -0,0 +1,125 @@
+import { BadRequestException, Controller, Get, Query } from '@nestjs/common';
+import * as dotenv from 'dotenv';
+import { EnvironmentService } from '@core/constants/environment.service';
+import { AuditService } from './audit.service';
+import { createDynamoClient } from '@core/constants/environment.db';
+import { AUDIT_TABLE } from './audit.schema';
+import { QueryCommand, ScanCommand } from '@aws-sdk/lib-dynamodb';
+import { SkipAuditLog } from '@core/filters/audit.decorator';
+dotenv.config();
+
+let cached: { db: any } | undefined;
+
+@SkipAuditLog()
+@Controller('audit-logs')
+export class AuditController {
+  constructor(
+    private readonly auditTable = AUDIT_TABLE,
+    private readonly auditService: AuditService,
+    private readonly config: EnvironmentService,
+  ) {}
+
+  public repository(): { db: any } {
+    try {
+      if (!cached) {
+        const db = createDynamoClient(this.config);
+
+        cached = { db };
+      }
+      return cached!;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getAllAudits({ limit: parsedLimit, nextToken }: any): Promise<any> {
+    let userId: string = 'anonymous';
+    try {
+      const params: any = {
+        TableName: this.auditTable,
+        KeyConditionExpression: 'userId = :userId',
+        ExpressionAttributeValues: {
+          ':userId': `${userId}`,
+        },
+        Limit: parsedLimit,
+        ScanIndexForward: false,
+      };
+      if (nextToken) {
+        params.ExclusiveStartKey = nextToken;
+      }
+      const { db } = this.repository();
+      return await db.send(new QueryCommand(params));
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getAuditsCount(): Promise<number> {
+    try {
+      const { db } = this.repository();
+      const { Count } = await db.send(
+        new ScanCommand({
+          TableName: this.auditTable,
+          Select: 'COUNT',
+        }),
+      );
+      return Count ?? 0;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  @Get()
+  async getAudits(@Query() query: any): Promise<any> {
+    try {
+      let { limit, nextToken } = query;
+      let prevPage: any = 1;
+      try {
+        const validToken = (val: string) =>
+          val && val !== 'null' && val !== 'undefined';
+        if (validToken(nextToken)) {
+          const splitToken: any = nextToken?.split(':');
+          nextToken = splitToken[0];
+          prevPage = splitToken[1];
+          nextToken = JSON.parse(
+            Buffer.from(nextToken as string, 'base64').toString('utf-8'),
+          );
+        } else {
+          nextToken = undefined;
+        }
+      } catch (err) {
+        throw new BadRequestException('Invalid pagination token');
+      }
+
+      let audits;
+
+      const parsedLimit = Number(limit ?? '10');
+      const total = await this.getAuditsCount();
+      const result = await this.getAllAudits({
+        limit: parsedLimit,
+        nextToken,
+      });
+
+      const page = !nextToken ? prevPage : Number(prevPage) + 1;
+      nextToken = result.LastEvaluatedKey
+        ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString(
+            'base64',
+          )
+        : undefined;
+      const response = {
+        logs: result.Items,
+        count: result.Items?.length,
+        total,
+        page,
+        pageSize: parsedLimit,
+        nextToken:
+          !nextToken || page * Number(limit) === total
+            ? null
+            : `${nextToken}:${page}`,
+      };
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+}