simpledi-app-generator 0.0.1

package/dist/templates/src/BaseRepository.ts

@@ -0,0 +1,136 @@
+import type { IRepository } from './IRepository';
+import type { NeonHttpDatabase } from 'drizzle-orm/neon-http';
+import type { PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { and, eq, sql } from 'drizzle-orm';
+import { getDb } from 'db/getDb';
+import type { BaseEntityInterface } from '@root/lib';
+import * as schema from './schema';
+import type { DbService } from 'db/DbService';
+export abstract class BaseRepository<
+  T extends BaseEntityInterface,
+  TSchema extends PgTableWithColumns<any> = PgTableWithColumns<any>,
+> implements IRepository<T> {
+  private readonly _db!: NeonHttpDatabase<typeof schema>;
+  private readonly _schema!: TSchema;
+
+  constructor(schema: TSchema, dbService: DbService) {
+    this._db = dbService.getDb();
+    this._schema = schema;
+  }
+
+  get schema() {
+    return this._schema;
+  }
+
+  get db() {
+    return this._db;
+  }
+  async create(entity: Partial<T>): Promise<Partial<T>> {
+    // Remove undefined values
+    const filteredValues = Object.fromEntries(
+      Object.entries(entity).filter(([_, v]) => v !== undefined),
+    );
+    try {
+      const [insertedEntity] = await this._db
+        .insert(this._schema)
+        .values(filteredValues as any)
+        .returning();
+
+      return insertedEntity as Partial<T>;
+    } catch (error) {
+      console.error('Error creating entity:', error);
+      throw error;
+    }
+  }
+
+  async findById(id: string, withDeleted = false): Promise<T | null> {
+    const conditions = [
+      eq(this._schema.id, id),
+      withDeleted ? undefined : eq(this._schema.deleted, false),
+    ];
+
+    const result = await this._db
+      .select()
+      .from(this._schema)
+      .where(and(...conditions));
+    return result.length > 0 ? (result[0] as unknown as T) : null;
+  }
+
+  async findAll(withDeleted = false): Promise<T[]> {
+    const conditions = withDeleted
+      ? undefined
+      : eq(this._schema.deleted, false);
+
+    return (await this._db
+      .select()
+      .from(this._schema)
+      .where(conditions)) as unknown as T[];
+  }
+
+  async update(id: string, entity: Partial<T>): Promise<T | null> {
+    try {
+      // Remove undefined values
+      const filteredValues = Object.fromEntries(
+        Object.entries(entity).filter(
+          ([_, v]) => v !== undefined || v === null,
+        ),
+      );
+      const result = await this._db
+        .update(this._schema)
+        .set(filteredValues as any)
+        .where(eq(this._schema.id, id))
+        .returning();
+      const updated = Array.isArray(result) ? result[0] : null;
+      return updated as unknown as T | null;
+    } catch (e) {
+      console.error('Error updating entity:', e);
+      throw e;
+    }
+  }
+
+  async delete(id: string, soft = true): Promise<boolean> {
+    try {
+      if (soft) {
+        const updatedAt = new Date();
+        const [result] = await this._db
+          .update(this._schema)
+          .set({
+            updatedAt,
+            deletedAt: updatedAt,
+            deleted: true,
+          })
+          .where(eq(this._schema.id, id))
+          .returning({ id: this._schema.id });
+
+        return !!result;
+      } else {
+        const result = await this._db
+          .delete(this._schema)
+          .where(eq(this._schema.id, id));
+
+        return result.rowCount > 0;
+      }
+    } catch (error) {
+      console.error('Error deleting entity:', error);
+      throw error;
+    }
+  }
+
+  /**
+   *
+   * @param config - The configuration object for the query.
+   * @returns A promise that resolves to an array of entities.
+   * @description This method is used to find multiple entities in the database.
+   * It can take a configuration object that specifies the query parameters.
+   * The configuration object can include the following properties:
+   * - where: The conditions to filter the results.
+   * - orderBy: The column to order the results by.
+   * - limit: The maximum number of results to return.
+   * - offset: The number of results to skip.
+   * - with: The related entities to include in the results.
+   * - withDeleted: Whether to include deleted entities in the results.
+   */
+  abstract find(config?: any): Promise<T[]>;
+
+  abstract findOne(config?: any): Promise<T>;
+}

package/dist/templates/src/BaseService.ts

@@ -0,0 +1,78 @@
+import type { IRepository } from './IRepository';
+import { randomUUIDv7 } from 'bun';
+import type { IService } from './IService';
+import type { ZodObject } from 'zod';
+import { type BaseEntityInterface } from '@root/lib';
+
+export abstract class BaseService<
+  T extends BaseEntityInterface,
+  U extends ZodObject<any> = ZodObject<any>,
+> implements IService<T> {
+  constructor(
+    private readonly repository: IRepository<T>,
+    private readonly insertSchema: U,
+    private readonly updateSchema: U,
+    private readonly selectSchema: U,
+  ) {}
+
+  async create(entity: Partial<T>): Promise<Partial<T>> {
+    try {
+      if (entity.id === undefined || entity.id === null) {
+        entity.id = randomUUIDv7();
+      }
+      entity.createdAt = new Date();
+      const result = this.insertSchema.safeParse(entity);
+      if (!result.success) {
+        return Promise.reject(result.error);
+      }
+      return await this.repository.create(entity);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async find(config?: any): Promise<T[]> {
+    return await this.repository.find(config);
+  }
+
+  async findOne(config?: any): Promise<T> {
+    return await this.repository.findOne(config);
+  }
+
+  async findById(id: string, withDeleted?: boolean): Promise<T | null> {
+    try {
+      return await this.repository.findById(id, withDeleted);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async findAll(withDeleted?: boolean): Promise<Partial<T>[]> {
+    try {
+      return await this.repository.findAll(withDeleted);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async update(id: string, entity: Partial<T>): Promise<Partial<T> | null> {
+    try {
+      entity.updatedAt = new Date();
+      const result = this.updateSchema.safeParse(entity);
+      if (!result.success) {
+        return Promise.reject(result.error);
+      }
+      return await this.repository.update(id, entity);
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+  }
+
+  async delete(id: string, soft: boolean): Promise<boolean> {
+    return await this.repository.delete(id, soft);
+  }
+}

package/dist/templates/src/IRepository.ts

@@ -0,0 +1,11 @@
+import type { BaseEntityInterface } from '@root/lib';
+
+export interface IRepository<T extends BaseEntityInterface> {
+  create(entity: Partial<T>): Promise<Partial<T>>;
+  findById(id: string, withDeleted?: boolean): Promise<T | null>;
+  findAll(withDeleted?: boolean): Promise<Partial<T>[]>;
+  update(id: string, entity: Partial<T>): Promise<Partial<T> | null>;
+  delete(id: string, soft: boolean): Promise<boolean>;
+  find(config?: any): Promise<T[]>;
+  findOne(config?: any): Promise<T>;
+}

package/dist/templates/src/IService.ts

@@ -0,0 +1,6 @@
+import type { BaseEntityInterface } from '@root/lib';
+import type { IRepository } from './IRepository';
+
+export interface IService<
+  T extends BaseEntityInterface,
+> extends IRepository<T> {}

package/dist/templates/src/core/baseSchema.ts

@@ -0,0 +1,13 @@
+import { boolean, timestamp, uuid } from 'drizzle-orm/pg-core';
+
+// Base entity schema with common fields
+export const baseSchema = {
+  id: uuid('id').primaryKey().defaultRandom(),
+  createdAt: timestamp('created_at').defaultNow(),
+  updatedAt: timestamp('updated_at').defaultNow(),
+  deleted: boolean('deleted').default(false),
+  deletedAt: timestamp('deleted_at').defaultNow(),
+  createdBy: uuid('created_by'),
+  updatedBy: uuid('updated_by'),
+};
+export type BaseSchemaType = typeof baseSchema;

package/dist/templates/src/lib/AuthenticationUtils.ts

@@ -0,0 +1,49 @@
+import jwt from 'jsonwebtoken';
+import type {
+  PhoneNumberInterface,
+  TokenPayload,
+  UserInterface,
+} from './types';
+
+export class AuthenticationUtils {
+  // Secure password hashing using Bun.password.hash
+  static async hashPassword(password: string): Promise<string> {
+    return Bun.password.hash(password);
+  }
+
+  // Password verification method using Bun.password.verify
+  static async verifyPassword(
+    inputPassword: string,
+    storedHash: string,
+  ): Promise<boolean> {
+    return Bun.password.verify(inputPassword, storedHash);
+  }
+
+  static async generateToken(user: Partial<UserInterface>): Promise<string> {
+    // Replace with your actual secret key
+    const secretKey = process.env.JWT_SECRET || 'your-secret-key'; // NEVER hardcode secrets in production!
+
+    const token = jwt.sign(
+      {
+        userId: user.id,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        phoneNumber: user.phoneNumber as PhoneNumberInterface,
+        roles: user.roles,
+        email: user.email,
+        inviteCode: user.inviteCode,
+        exp: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
+        iat: Math.floor(Date.now() / 1000),
+      },
+      secretKey,
+    );
+    return token;
+  }
+
+  static verifyToken(token: string): string | TokenPayload {
+    // Replace with your actual secret key
+    const secretKey = process.env.JWT_SECRET || 'your-secret-key'; // NEVER hardcode secrets in production!
+    const verified: TokenPayload = jwt.verify(token, secretKey) as TokenPayload;
+    return verified;
+  }
+}

package/dist/templates/src/lib/errors/BadRequestException.ts

@@ -0,0 +1,11 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class BadRequestException extends HttpException {
+  readonly name = 'BadRequestException';
+  constructor(
+    response: string | Record<string, any> = ReasonPhrases.BAD_REQUEST,
+  ) {
+    super(response, StatusCodes.BAD_REQUEST);
+  }
+}

package/dist/templates/src/lib/errors/ConflictException.ts

@@ -0,0 +1,9 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class ConflictException extends HttpException {
+  readonly name = 'ConflictException';
+  constructor(response: string | Record<string, any> = ReasonPhrases.CONFLICT) {
+    super(response, StatusCodes.CONFLICT);
+  }
+}

package/dist/templates/src/lib/errors/ForbiddenException.ts

@@ -0,0 +1,11 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class ForbiddenException extends HttpException {
+  readonly name = 'ForbiddenException';
+  constructor(
+    response: string | Record<string, any> = ReasonPhrases.FORBIDDEN,
+  ) {
+    super(response, StatusCodes.FORBIDDEN);
+  }
+}

package/dist/templates/src/lib/errors/HttpException.ts

@@ -0,0 +1,22 @@
+/**
+ * Defines the base HTTP exception
+ */
+export class HttpException extends Error {
+  /**
+   * Instantiate a plain HTTP Exception.
+   *
+   * @example
+   * \`throw new HttpException()\`
+   * The \`status\` argument is required, and should be a valid HTTP status code.
+   * Best practice is to use the \`HttpStatus\` enum imported from \`nestjs/common\`.
+   *
+   * @param response string or object describing the error condition.
+   * @param status HTTP response status code.
+   */
+  constructor(
+    private readonly response: string | Record<string, any>,
+    readonly status: number,
+  ) {
+    super(typeof response === 'string' ? response : JSON.stringify(response));
+  }
+}

package/dist/templates/src/lib/errors/InternalServerException.ts

@@ -0,0 +1,13 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class InternalServerException extends HttpException {
+  readonly name = 'NotFoundException';
+  constructor(
+    response:
+      | string
+      | Record<string, any> = ReasonPhrases.INTERNAL_SERVER_ERROR,
+  ) {
+    super(response, StatusCodes.INTERNAL_SERVER_ERROR);
+  }
+}

package/dist/templates/src/lib/errors/NotFoundException.ts

@@ -0,0 +1,11 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class NotFoundException extends HttpException {
+  readonly name = 'NotFoundException';
+  constructor(
+    response: string | Record<string, any> = ReasonPhrases.NOT_FOUND,
+  ) {
+    super(response, StatusCodes.NOT_FOUND);
+  }
+}

package/dist/templates/src/lib/errors/UnauthorizedException.ts

@@ -0,0 +1,11 @@
+import { HttpException } from './HttpException';
+import { ReasonPhrases, StatusCodes } from 'http-status-codes';
+
+export class UnauthorizedException extends HttpException {
+  readonly name = 'UnauthorizedException';
+  constructor(
+    response: string | Record<string, any> = ReasonPhrases.UNAUTHORIZED,
+  ) {
+    super(response, StatusCodes.UNAUTHORIZED);
+  }
+}

package/dist/templates/src/lib/functions/getEnvFile.ts

@@ -0,0 +1,19 @@
+import { EnvFileNames } from '../types/EnvFileNames';
+import { Envs } from '../types/Envs';
+
+export const getEnvFile = () => {
+  switch (process.env.BUN_ENV) {
+    case Envs.DEVELOPMENT:
+      return EnvFileNames.DEVELOPMENT;
+    case Envs.TESTING:
+      return EnvFileNames.TESTING;
+    case Envs.PRODUCTION:
+      return EnvFileNames.PRODUCTION;
+    case Envs.DEBUGGING:
+      return EnvFileNames.DEBUGGING;
+    case Envs.STAGING:
+      return EnvFileNames.STAGING;
+    default:
+      return undefined;
+  }
+};

package/dist/templates/src/lib/functions/getHostname.ts

@@ -0,0 +1,18 @@
+import { Envs } from '@root/lib';
+
+/**
+ * Returns the hostname based on the current environment.
+ * @returns The hostname based on the current environment.
+ */
+export function getHostname(): string {
+  const env = process.env.BUN_ENV || Envs.DEVELOPMENT;
+  console.log(`getHostname: Current environment is ${env}`);
+  if (env === Envs.PRODUCTION || env === Envs.STAGING) {
+    console.warn(
+      `getHostname: Running in ${env} environment, returning '0.0.0.0')`,
+    );
+    return '0.0.0.0';
+  } else {
+    return 'localhost';
+  }
+}

package/dist/templates/src/lib/functions/isNotNullNorUndefined.ts

@@ -0,0 +1,5 @@
+export function isNotNullNorUndefined<T>(
+  value: T | null | undefined,
+): value is T {
+  return value !== null && value !== undefined;
+}

package/dist/templates/src/lib/functions/tableName.ts

@@ -0,0 +1,5 @@
+import type { TableNameToken } from '../types/TableNameToken';
+
+export const tableName = (tableName: string): TableNameToken => {
+  return tableName as TableNameToken;
+};

package/dist/templates/src/lib/functions/withBaseSchema.ts

@@ -0,0 +1,30 @@
+import { pgTable } from 'drizzle-orm/pg-core';
+import type { TableNameToken } from '../types/TableNameToken';
+import { baseSchema } from '@root/core/baseSchema';
+
+export const withBaseSchema = <T>(
+  tableName: TableNameToken | string,
+  schemaObj: T,
+  extraConfig?: any,
+  baseSchemaOverrides: any = {},
+) => {
+  let _baseSchema = { ...baseSchema };
+  const overridesKeys: string[] = Object.keys(baseSchemaOverrides);
+  const baseSchemaKeys: string[] = Object.keys(baseSchema);
+  overridesKeys.forEach((key) => {
+    if (baseSchemaKeys.includes(key)) {
+      _baseSchema = {
+        ..._baseSchema,
+        [key]: baseSchemaOverrides[key],
+      };
+    }
+  });
+  return pgTable(
+    tableName,
+    {
+      ...schemaObj,
+      ..._baseSchema,
+    },
+    extraConfig,
+  );
+};

package/dist/templates/src/lib/types/BaseEntityInterface.ts

@@ -0,0 +1,9 @@
+export interface BaseEntityInterface {
+  id: string;
+  createdAt: Date | null;
+  updatedAt: Date | null;
+  deletedAt: Date | null;
+  deleted: boolean;
+  createdBy: string | null;
+  updatedBy: string | null;
+}

package/dist/templates/src/lib/types/EnvFileNames.ts

@@ -0,0 +1,7 @@
+export enum EnvFileNames {
+  PRODUCTION = '.env.prod',
+  DEVELOPMENT = '.env.development',
+  TESTING = '.env.testing',
+  DEBUGGING = '.env.debugging',
+  STAGING = '.env.staging',
+}

package/dist/templates/src/lib/types/Envs.ts

@@ -0,0 +1,7 @@
+export enum Envs {
+  PRODUCTION = 'prod',
+  STAGING = 'staging',
+  DEVELOPMENT = 'dev',
+  TESTING = 'test',
+  DEBUGGING = 'debug',
+}

package/dist/templates/src/lib/types/FailedOperation.ts

@@ -0,0 +1,9 @@
+import { OperationResult } from './OperationResult';
+
+export class FailedOperation extends OperationResult {
+  public readonly success = false;
+  public readonly result = null;
+  constructor(readonly message = 'Failed Operation') {
+    super();
+  }
+}

package/dist/templates/src/lib/types/OperationResult.ts

@@ -0,0 +1,5 @@
+export class OperationResult {
+  success!: boolean;
+  message!: string;
+  result: any;
+}

package/dist/templates/src/lib/types/SharedStubs.ts

@@ -0,0 +1,16 @@
+// Stubs for other missing types imported by copied files
+export type PhoneNumberInterface = any;
+export type Currency = string;
+export type PlaceType = string;
+export type LocationInterface = any;
+export type PlanInterface = any;
+export type ServiceCategoryInterface = any;
+export type ServiceRequestInterface = any;
+export type ServiceRequestPayload = any;
+export type PropertyInterface = any;
+export type WaveError = any;
+export const WaveErrorCodes = {};
+export type TelnyxError = any;
+export const TelnyxErrorCodes = {};
+export const retryWithIncreasingTime = async (fn: any) => fn();
+export const createKeyEnum = (keys: string[]) => keys;

package/dist/templates/src/lib/types/SuccessfullOperation.ts

@@ -0,0 +1,9 @@
+import { OperationResult } from './OperationResult';
+
+export class SuccessfullOperation extends OperationResult {
+  readonly success = true;
+
+  constructor(readonly message = 'Successfull Operation') {
+    super();
+  }
+}

package/dist/templates/src/lib/types/TableNameToken.ts

@@ -0,0 +1 @@
+export type TableNameToken = string & { readonly tableName: unique symbol };

package/dist/templates/src/lib/types/TokenPayload.ts

@@ -0,0 +1,6 @@
+export interface TokenPayload {
+  userId: string;
+  email: string;
+  roles: any[];
+  // Add other fields as necessary
+}

package/dist/templates/src/lib/types/UserInterface.ts

@@ -0,0 +1,10 @@
+export interface UserInterface {
+  id: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber?: any;
+  roles: any[];
+  inviteCode?: string;
+  // Add other fields as necessary
+}

package/dist/templates/src/lib/types/getCorsOrigin.ts

@@ -0,0 +1,20 @@
+import { inject } from '@kanian77/simple-di';
+import { Config, CONFIG } from 'config/Config';
+import { Envs } from '@root/lib';
+
+export const getCorsOrigin = () => {
+  if (
+    process.env.BUN_ENV !== Envs.PRODUCTION &&
+    process.env.BUN_ENV !== Envs.STAGING
+  ) {
+    // Filter out undefined/null/empty string if 'result' isn't a valid URL
+    // get frontendUrl from config
+    const frontendUrl = inject<Config>(CONFIG).frontendUrl;
+    console.log('frontendUrl in getCorsOrigin', frontendUrl);
+    return ['http://localhost:5173', frontendUrl];
+  } else {
+    // For production/staging, ensure a valid string or array of strings
+    const prodOrigin = process.env.CORS_ORIGIN;
+    return prodOrigin ? prodOrigin.split(',').map((s) => s.trim()) : ['*'];
+  }
+};

package/dist/templates/src/main.routes.ts

@@ -0,0 +1,11 @@
+import { Hono } from 'hono';
+import {
+  healthCheckRoutes,
+  healthCheckRoutesPath,
+} from './use-case/health-check/healthCheckRoutes';
+
+const mainRoutes = new Hono();
+
+mainRoutes.route(healthCheckRoutesPath, healthCheckRoutes);
+
+export { mainRoutes };

package/dist/templates/src/use-case/IUseCase.ts

@@ -0,0 +1,3 @@
+export interface IUseCase {
+  execute(...args: any[]): Promise<any>;
+}

package/dist/templates/src/use-case/UseCaseModule.ts

@@ -0,0 +1,6 @@
+import { Module } from '@kanian77/simple-di';
+import { HealthCheckModule } from './health-check/HealthCheck';
+
+export const UseCaseModule = new Module({
+  imports: [HealthCheckModule],
+});

package/dist/templates/src/use-case/health-check/HealthCheck.ts

@@ -0,0 +1,24 @@
+import { Module, Service } from '@kanian77/simple-di';
+import type { IUseCase } from '../IUseCase';
+import {
+  HealthCheckSuccess,
+  type HealthCheckPayload,
+} from './outputs/HealthCheckSuccess';
+
+export const HEALTH_CHECK_USE_CASE_TOKEN = 'HEALTH_CHECK_USE_CASE';
+
+@Service({
+  token: HEALTH_CHECK_USE_CASE_TOKEN,
+  lifecycle: 'transient',
+})
+export class HealthCheck implements IUseCase {
+  async execute(): Promise<HealthCheckSuccess> {
+    const result: HealthCheckPayload = { status: 'healthy' };
+    return new HealthCheckSuccess(result);
+  }
+}
+
+export const HealthCheckModule = new Module({
+  imports: [],
+  providers: [{ provide: HEALTH_CHECK_USE_CASE_TOKEN, useClass: HealthCheck }],
+});