@solidxai/core 0.1.6-beta.2 → 0.1.6-beta.21

package/src/entities/dashboard.entity.ts

@@ -1,8 +1,10 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, Column, Index, OneToMany, JoinColumn, ManyToOne } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
 import { DashboardQuestion } from 'src/entities/dashboard-question.entity';
 import { ModuleMetadata } from 'src/entities/module-metadata.entity'
+import { DashboardLayout } from './dashboard-layout.entity';
 
 @Entity("ss_dashboard")
 export class Dashboard extends CommonEntity {
@@ -10,7 +12,7 @@ export class Dashboard extends CommonEntity {
     @Column({ type: "varchar" })
     name: string;
 
-    @Column({ type: "text" })
+    @Column({ ...getColumnType('longText'), nullable: true })
     layoutJson: any;
 
     @OneToMany(() => DashboardVariable, dashboardVariable => dashboardVariable.dashboard, { cascade: true })
@@ -19,6 +21,9 @@ export class Dashboard extends CommonEntity {
     @OneToMany(() => DashboardQuestion, dashboardQuestion => dashboardQuestion.dashboard, { cascade: true })
     questions: DashboardQuestion[];
 
+    @OneToMany(() => DashboardLayout, dashboardLayout => dashboardLayout.dashboard, { cascade: true })
+    dashboardLayouts: DashboardLayout[];
+
     @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn()
     module: ModuleMetadata;
@@ -26,6 +31,6 @@ export class Dashboard extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     displayName: string;
 
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true })
     description: string;
 }

package/src/entities/email-attachment.entity.ts

@@ -1,6 +1,7 @@
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import { CommonEntity } from "./common.entity";
 import { EmailTemplate } from "./email-template.entity";
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { IndentLogger } from "@angular-devkit/core/src/logger";
 
 @Entity("ss_email_attachment")
@@ -14,7 +15,7 @@ export class EmailAttachment extends CommonEntity {
     relativePath: string; // This is the path relative to the email service being used. For e.g if the attahchment is uploaded in the media manager of elastic email service
     @Column({ name: "url", type: "varchar", nullable: true })
     url: string;
-    @Column({ name: "template", type: "text", nullable: true })
+    @Column({ name: "template", nullable: true, ...getColumnType('longText') })
     template: string;
     @Index()
     @ManyToOne(() => EmailTemplate, (template) => template.attachments, { onDelete: 'CASCADE' })

package/src/entities/email-template.entity.ts

@@ -14,7 +14,7 @@ export class EmailTemplate extends CommonEntity {
     body: string;
     @Column({ name: "subject", type: "varchar", default: "{}" })
     subject: string = "{}";
-    @Column({ name: "description", type: "text", nullable: true })
+    @Column({ name: "description", nullable: true })
     description: string;
     @Column({ name: "active", nullable: true, default: true })
     active: boolean = true;

package/src/entities/export-transaction.entity.ts

@@ -1,6 +1,7 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, Column, Index, ManyToOne } from 'typeorm';
 import { ExportTemplate } from 'src/entities/export-template.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_export_transaction")
 @Index(["exportTransactionId", "deletedTracker"], { unique: true })
@@ -14,7 +15,7 @@ export class ExportTransaction extends CommonEntity {
     @Index()
     @Column({ type: "varchar" })
     status: string;
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     error: string;
     @Index()
     @ManyToOne(() => ExportTemplate, { nullable: true })

package/src/entities/field-metadata.entity.ts

@@ -36,7 +36,7 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'regex_pattern', nullable: true })
     regexPattern: string;
 
-    @Column({ name: 'regex_pattern_not_matching_error_msg', type: 'text', nullable: true, default: ERROR_MESSAGES.DEFAULT_REGEX_PATTERN_NOT_MATCHING_ERROR_MSG })
+    @Column({ name: 'regex_pattern_not_matching_error_msg', nullable: true, default: ERROR_MESSAGES.DEFAULT_REGEX_PATTERN_NOT_MATCHING_ERROR_MSG })
     regexPatternNotMatchingErrorMsg: string;
 
     @Column({ name: "required", default: false })
@@ -119,7 +119,7 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'selection_static_values', nullable: true, type: 'simple-array' })
     selectionStaticValues: string[];
 
-    @Column({ name: 'selection_value_type', nullable: true, type: 'text' }) // text type cannot have a default value
+    @Column({ name: 'selection_value_type', nullable: true })
     selectionValueType: string = 'string';
 
     // @Column({ name: "computed", default: false })

package/src/entities/import-transaction-error-log.entity.ts

@@ -1,6 +1,7 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, Column, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { ImportTransaction } from 'src/entities/import-transaction.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_import_transaction_error_log")
 export class ImportTransactionErrorLog extends CommonEntity {
@@ -9,7 +10,7 @@ export class ImportTransactionErrorLog extends CommonEntity {
     importTransactionErrorLogId: string;
     @Column({ type: "integer" })
     rowNumber: number;
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     rowData: any;
     @Index()
     @ManyToOne(() => ImportTransaction, { nullable: false })
@@ -17,6 +18,6 @@ export class ImportTransactionErrorLog extends CommonEntity {
     importTransaction: ImportTransaction;
     @Column({ type: "varchar" })
     errorMessage: string;
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     errorTrace: string;
 }

package/src/entities/import-transaction.entity.ts

@@ -2,13 +2,14 @@ import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { ImportTransactionErrorLog } from 'src/entities/import-transaction-error-log.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_import_transaction")
 export class ImportTransaction extends CommonEntity {
     @Index()
     @Column({ type: "varchar", nullable: true, default: "draft" })
     status: string = "draft";
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     mapping: any;
     @Index()
     @ManyToOne(() => ModelMetadata, { nullable: true })

package/src/entities/legacy-common.entity.ts

@@ -1,7 +1,6 @@
-import { Exclude, Expose, Type } from "class-transformer";
-import { Column, CreateDateColumn, DeleteDateColumn, Index, JoinColumn, ManyToOne, UpdateDateColumn } from "typeorm";
-import type { User } from "./user.entity";
-import { LocalDateTimeTransformer, UtcDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
+import { Exclude, Expose } from "class-transformer";
+import { LocalDateTimeTransformer } from "src/transformers/typeorm/local-date-time-transformer";
+import { Column, CreateDateColumn, DeleteDateColumn, Index, UpdateDateColumn } from "typeorm";
 
 export const LEGACY_TABLE_FIELDS_PREFIX = 'ss';
 

package/src/entities/mq-message.entity.ts

@@ -1,8 +1,10 @@
 import { CommonEntity } from "src/entities/common.entity"
 import { Entity, Column, Index, ManyToOne } from "typeorm";
 import { MqMessageQueue } from 'src/entities/mq-message-queue.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 @Entity("ss_mq_message")
 export class MqMessage extends CommonEntity {
+    @Index()
     @Column({ type: "varchar", nullable: true })
     messageId: string;
 
@@ -31,13 +33,13 @@ export class MqMessage extends CommonEntity {
     @Column({ type: "integer", nullable: true })
     elapsedMillis: number;
 
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     input: string;
 
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     output: string;
 
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     error: string;
 
     @Column({ type: "integer", nullable: true })

package/src/entities/saved-filters.entity.ts

@@ -3,10 +3,11 @@ import { Entity, Column, JoinColumn, ManyToOne, Index } from 'typeorm';
 import { User } from 'src/entities/user.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { ViewMetadata } from 'src/entities/view-metadata.entity'
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_saved_fitlers")
 export class SavedFilters extends CommonEntity {
-    @Column({ type: "text", nullable: true })
+    @Column({ nullable: true, ...getColumnType('longText') })
     filterQueryJson: any;
 
     @Index({ unique: true })
@@ -28,7 +29,7 @@ export class SavedFilters extends CommonEntity {
     @JoinColumn()
     view: ViewMetadata;
 
-    @Column({ name: "description", type: "text", nullable: true })
+    @Column({ name: "description", nullable: true })
     description: string;
 
     @Column({ nullable: true, default: false })

package/src/entities/security-rule.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { RoleMetadata } from 'src/entities/role-metadata.entity';
 import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 
 @Entity("ss_security_rule")
 export class SecurityRule extends CommonEntity {
@@ -22,7 +23,7 @@ export class SecurityRule extends CommonEntity {
     @JoinColumn()
     modelMetadata: ModelMetadata;
 
-    @Column({ type: "text" })
+    @Column({ ...getColumnType('longText'), nullable: true })
     securityRuleConfig: any;
 
     @Column({ type: "varchar", nullable: true })

package/src/entities/sms-template.entity.ts

@@ -12,7 +12,7 @@ export class SmsTemplate extends CommonEntity {
     body: string;
     @Column({ type: "varchar", nullable: true })
     smsProviderTemplateId: string;
-    @Column({ name: "description", type: "text", nullable: true })
+    @Column({ name: "description", nullable: true })
     description: string;
     @Column({ name: "active", nullable: true, default: true })
     active: boolean = true;

package/src/entities/user-view-metadata.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from 'src/entities/common.entity'
 import { Entity, JoinColumn, ManyToOne, Index, Column } from 'typeorm';
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { ViewMetadata } from 'src/entities/view-metadata.entity';
 import { User } from 'src/entities/user.entity'
 
@@ -9,7 +10,7 @@ export class UserViewMetadata extends CommonEntity {
     @ManyToOne(() => User, { nullable: false })
     @JoinColumn()
     user: User;
-    @Column({ name: "layout", type: "text", nullable: true })
+    @Column({ name: "layout", nullable: true, ...getColumnType('longText') })
     layout: any = "{}";
     @Index()
     @ManyToOne(() => ViewMetadata, { nullable: false })

package/src/entities/user.entity.ts

@@ -11,109 +11,144 @@ export class User extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     @Expose()
     fullName: string;
+
     @Index({ unique: true })
     @Column({ type: "varchar" })
     @Expose()
     username: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     email: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     mobile: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     password: string;
+
     @Column({ nullable: true, default: true })
     @Expose()
     forcePasswordChange: boolean = true;
+
     @Column({ type: "varchar", default: "local" })
     // don't send to client
     lastLoginProvider: string = "local";
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client (test)
     accessCode: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleAccessToken: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleId: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleProfilePicture: string;
+
     @Column({ default: true })
     @Expose()
     active: boolean = true;
+
     @Column({ nullable: true })
     // don't send to client
     forgotPasswordConfirmedAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     verificationTokenOnForgotPassword: string;
+
     @Column({ nullable: true })
     // don't send to client
     verificationTokenOnForgotPasswordExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     @Expose()
     customPayload: string;
+
     @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
     @JoinTable()
     @Expose()
     roles: RoleMetadata[];
+
     @OneToMany(() => UserViewMetadata, userViewMetadata => userViewMetadata.user, { cascade: true })
     // don't send to client
     userViewMetadata: UserViewMetadata[];
+
     // dont send to client
     @Column({ type: "varchar", default: "bcrypt" })
     passwordScheme: string;
+
     // dont send to client
     @Column({ type: "int", default: 1 })
     passwordSchemeVersion: number;
+
     // dont send to client
     @Column({ nullable: true })
     rehashedAt: Date;
+
     // dont send to client
     @Column({ type: "int", default: 0 })
     failedLoginAttempts: number = 0;
+
     @Expose()
     _media: any;
+
 }

package/src/entities/view-metadata.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from "src/entities/common.entity"
 import { Entity, Column, ManyToOne, Index, JoinColumn, OneToMany } from "typeorm";
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { ModuleMetadata } from 'src/entities/module-metadata.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
@@ -16,9 +17,11 @@ export class ViewMetadata extends CommonEntity {
     @Column({ name: "type", type: "varchar" })
     type: string;
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "context", type: "text" })
     context: any = "{}";
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "layout", type: "text" })
     layout: any;
 

package/src/helpers/bootstrap.helper.ts

@@ -0,0 +1,222 @@
+import { ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { NextFunction, Request, Response } from 'express';
+import helmet from 'helmet';
+import qs from 'qs';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+import { CommandFactory } from 'nest-commander';
+import { WrapResponseInterceptor } from '../interceptors/wrap-response.interceptor';
+import { buildDefaultCorsOptions } from './cors.helper';
+import { buildDefaultSecurityHeaderOptions, buildPermissionsPolicyHeader, PermissionsPolicyConfig } from './security.helper';
+import { parseBooleanEnv } from './environment.helper';
+
+// ---- Shared process handlers ----
+
+function registerGlobalProcessHandlers() {
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  });
+
+  process.on('uncaughtException', (err) => {
+    console.error('Uncaught Exception thrown:', err);
+  });
+
+  // Suppress pg deprecation warning caused by TypeORM's internal query scheduling
+  process.on('warning', (warning) => {
+    if (warning.name === 'DeprecationWarning' && (warning.message.includes('client.query()') || warning.message.includes('punycode'))) {
+      return;
+    }
+    console.warn(warning);
+  });
+}
+
+// ---- HTTP server bootstrap ----
+
+export interface SolidSwaggerOptions {
+  title?: string;
+  description?: string;
+  version?: string;
+}
+
+export interface SolidBootstrapOptions {
+  /** Global API prefix. Defaults to 'api'. Set to '' to disable. */
+  globalPrefix?: string;
+  /** Swagger configuration. Set to false to disable Swagger entirely. */
+  swagger?: SolidSwaggerOptions | false;
+  /** Permissions-Policy header overrides (merged with defaults). */
+  permissionsPolicyOverrides?: Partial<PermissionsPolicyConfig>;
+}
+
+/**
+ * Bootstraps a SolidX NestJS HTTP application with sensible defaults:
+ * security headers, CORS, Winston logger, ValidationPipe,
+ * WrapResponseInterceptor, qs deep query parsing, Swagger, and the
+ * pg BIGINT type parser.
+ *
+ * @example
+ * // main.ts
+ * bootstrapSolidApp(() => AppModule.forRoot(), {
+ *   swagger: { title: 'My API', description: 'My API description' },
+ * });
+ */
+export async function bootstrapSolidApp(
+  appModuleFactory: () => Promise<any>,
+  options: SolidBootstrapOptions = {},
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  const { globalPrefix = 'api', swagger = {}, permissionsPolicyOverrides = {} } = options;
+
+  const appModule = await appModuleFactory();
+  const app = await NestFactory.create(appModule);
+
+  const apiEnabled = parseBooleanEnv('API_ENABLED', true);
+
+  if (!apiEnabled) {
+    await app.init();
+    app
+      .get(WINSTON_MODULE_NEST_PROVIDER)
+      .log('API server disabled via API_ENABLED=false. Skipping HTTP listen.', 'Bootstrap');
+    return;
+  }
+
+  // Health check at root path
+  const server = app.getHttpAdapter().getInstance();
+  server.get('/', (_req, res) => res.status(200).send('SOLID OK'));
+
+  // Security headers
+  app.use(helmet(buildDefaultSecurityHeaderOptions()));
+
+  // Permissions-Policy header
+  app.use((_req: Request, res: Response, next: NextFunction) => {
+    res.setHeader('Permissions-Policy', buildPermissionsPolicyHeader(permissionsPolicyOverrides));
+    next();
+  });
+
+  // Winston logger
+  app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER));
+
+  const port = process.env.PORT || 3000;
+
+  if (globalPrefix) {
+    app.setGlobalPrefix(globalPrefix);
+  }
+
+  // qs-based deep query parsing (dot notation, nested objects, arrays)
+  app.use((req: Request, _res: Response, next: NextFunction) => {
+    if (req.query) {
+      req.query = qs.parse(req.url.split('?')[1], {
+        allowDots: true,
+        depth: 10,
+        arrayLimit: 100,
+      });
+    }
+    next();
+  });
+
+  // Global ValidationPipe
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true,
+      transformOptions: { enableImplicitConversion: true },
+    }),
+  );
+
+  // Swagger
+  if (swagger !== false) {
+    const { title = 'Solid Starters', description = 'Solid Starters API', version = '1.0' } = swagger;
+    const swaggerConfig = new DocumentBuilder()
+      .setTitle(title)
+      .setDescription(description)
+      .setVersion(version)
+      .setExternalDoc('Postman Collection', '/docs-json')
+      .addBearerAuth(
+        {
+          description: 'Please enter token in following format: Bearer <JWT>',
+          name: 'Authorization',
+          bearerFormat: 'Bearer',
+          scheme: 'Bearer',
+          type: 'http',
+          in: 'Header',
+        },
+        'jwt',
+      )
+      .build();
+    const document = SwaggerModule.createDocument(app, swaggerConfig);
+    SwaggerModule.setup('/docs', app, document);
+  }
+
+  // Global interceptor
+  app.useGlobalInterceptors(new WrapResponseInterceptor());
+
+  // CORS
+  app.enableCors(buildDefaultCorsOptions());
+
+  // Fix pg returning BIGINT columns as strings
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const types = require('pg').types;
+  types.setTypeParser(types.builtins.INT8, (val: string) => parseInt(val));
+
+  await app.listen(port);
+}
+
+// ---- CLI bootstrap ----
+
+/**
+ * Bootstraps a SolidX NestJS CLI application using nest-commander.
+ * Handles verbose flag stripping, project root validation, and clean process exit.
+ *
+ * @example
+ * // main-cli.ts
+ * #!/usr/bin/env node
+ * import { bootstrapSolidCli } from '@solidxai/core';
+ * import { AppModule } from './app.module';
+ *
+ * bootstrapSolidCli(() => AppModule.forRoot());
+ */
+export async function bootstrapSolidCli(
+  appModuleFactory: () => Promise<any>,
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  process.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(`Exiting with error status code: ${code}`);
+    }
+  });
+
+  // Validate that cwd is a valid Solid API project
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    console.error('Does not seem to be a valid solid-api project.');
+    console.error('Exit reason: missing package.json in the current directory.');
+    process.exit(1);
+  }
+
+  // Strip --verbose / -v before nest-commander processes argv
+  const showLogs = process.argv.includes('--verbose') || process.argv.includes('-v');
+  for (const flag of ['--verbose', '-v']) {
+    const idx = process.argv.indexOf(flag);
+    if (idx !== -1) process.argv.splice(idx, 1);
+  }
+
+  const appModule = await appModuleFactory();
+  process.env.SOLID_CLI_RUNNING = 'true';
+
+  // @ts-ignore
+  const app = await CommandFactory.createWithoutRunning(appModule, {
+    logger: showLogs ? ['debug', 'error', 'fatal', 'log', 'verbose', 'warn'] : false,
+  });
+
+  try {
+    await CommandFactory.runApplication(app);
+  } catch (e) {
+    console.error('CLI exited abruptly due to an error:', e);
+    process.exit(1);
+  }
+
+  process.exit(0);
+}

package/src/helpers/cache.helper.ts

@@ -0,0 +1,5 @@
+export function shouldUseCache(): boolean {
+  const env = (process.env.ENV ?? process.env.NODE_ENV ?? '').toLowerCase();
+  return env === 'prod' || env === 'production';
+}
+