@jumentix/cli-init 0.0.0

package/templates/backend/src/infra/persistence/InMemoryDatabase/InMemoryDbClient.ts

@@ -0,0 +1,16 @@
+// import { Account } from '@src/domains/Accounts';
+import type { IDatabaseClient, IDbStores } from '../port/IDatabaseClient';
+import { UserStoreAPI } from './Stores/UserStoreAPI';
+import { OrganizationStoreAPI } from './Stores/OrganizationStoreAPI';
+
+export const InMemoryDbClient: IDatabaseClient = ((): IDatabaseClient => {
+  const stores: IDbStores = {
+    User: UserStoreAPI,
+    Organization: OrganizationStoreAPI
+  };
+  const connect = () => Promise.resolve();
+  const disconnect = () => Promise.resolve();
+  return { stores, connect, disconnect };
+})();
+
+// mongoose and sequelize

package/templates/backend/src/infra/persistence/InMemoryDatabase/Stores/InMemoryRelationalStore.ts

@@ -0,0 +1,209 @@
+import type { IStore } from '@src/infra/ports/persistence/IStore';
+import { ConflictError, DataBaseNotFoundError } from '@src/infra/exceptions';
+import type { IPagingRequest, IPagingResponse } from '@src/modules/port';
+import {
+  runListQuery,
+  type IIdReservationLedger
+} from '@jumentix/persistence-contracts';
+
+type Primitive = string | number | boolean | null | undefined;
+
+interface IStoreOptions<T extends Record<string, any>> {
+  uniqueIndexes?: (keyof T)[];
+  caseInsensitiveUniqueIndexes?: (keyof T)[];
+  relationIndexes?: (keyof T)[];
+  /** Soft-delete + hide tombstones. Off for catalog (own tombstone + restore). */
+  softDelete?: boolean;
+  entity?: string;
+  ledger?: IIdReservationLedger;
+}
+
+const stringifyPrimitive = (value: Primitive): string => String(value ?? '');
+
+export class InMemoryRelationalStore<T extends Record<string, any>> implements IStore<T> {
+  private readonly records = new Map<string, T>();
+
+  private readonly uniqueIndexes: Record<string, Map<string, string>> = {};
+
+  private readonly relationIndexes: Record<string, Map<string, Set<string>>> = {};
+
+  private readonly options: IStoreOptions<T>;
+
+  constructor(options: IStoreOptions<T> = {}) {
+    this.options = options;
+    const unique = options.uniqueIndexes || [];
+    const ciUnique = options.caseInsensitiveUniqueIndexes || [];
+    [...unique, ...ciUnique].forEach((field) => {
+      this.uniqueIndexes[field.toString()] = new Map<string, string>();
+    });
+    (options.relationIndexes || []).forEach((field) => {
+      this.relationIndexes[field.toString()] = new Map<string, Set<string>>();
+    });
+  }
+
+  private normalizeUniqueValue(field: string, value: Primitive): string {
+    const raw = stringifyPrimitive(value);
+    const ci = this.options.caseInsensitiveUniqueIndexes || [];
+    if (ci.includes(field as keyof T)) return raw.toLowerCase();
+    return raw;
+  }
+
+  private ensureUniqueIndexes(id: string, value: T, previous?: T): void {
+    Object.keys(this.uniqueIndexes).forEach((field) => {
+      const index = this.uniqueIndexes[field];
+      const normalized = this.normalizeUniqueValue(field, value[field]);
+      const linkedId = index.get(normalized);
+      if (linkedId && linkedId !== id) {
+        throw new ConflictError(`${field} already in use`);
+      }
+      if (previous) {
+        const previousNormalized = this.normalizeUniqueValue(field, previous[field]);
+        if (previousNormalized !== normalized) {
+          index.delete(previousNormalized);
+        }
+      }
+      index.set(normalized, id);
+    });
+  }
+
+  private syncRelationIndexes(id: string, value: T, previous?: T): void {
+    Object.keys(this.relationIndexes).forEach((field) => {
+      const index = this.relationIndexes[field];
+      const previousRef = previous ? stringifyPrimitive(previous[field] as Primitive) : '';
+      const nextRef = stringifyPrimitive(value[field] as Primitive);
+
+      if (previous && previousRef !== '' && previousRef !== nextRef) {
+        const set = index.get(previousRef);
+        if (set) {
+          set.delete(id);
+          if (set.size === 0) index.delete(previousRef);
+        }
+      }
+
+      if (nextRef !== '') {
+        const existing = index.get(nextRef) || new Set<string>();
+        existing.add(id);
+        index.set(nextRef, existing);
+      }
+    });
+  }
+
+  public async delete(id: string): Promise<boolean> {
+    const existing = this.records.get(id);
+    if (!existing) return false;
+    Object.keys(this.uniqueIndexes).forEach((field) => {
+      const normalized = this.normalizeUniqueValue(field, existing[field]);
+      this.uniqueIndexes[field].delete(normalized);
+    });
+    Object.keys(this.relationIndexes).forEach((field) => {
+      const ref = stringifyPrimitive(existing[field] as Primitive);
+      if (!ref) return;
+      const set = this.relationIndexes[field].get(ref);
+      if (!set) return;
+      set.delete(id);
+      if (set.size === 0) this.relationIndexes[field].delete(ref);
+    });
+    if (!this.options.softDelete) {
+      this.records.delete(id);
+      return true;
+    }
+    const tombstone = {
+      ...existing,
+      deletedAt: new Date().toISOString(),
+      updatedAt: new Date()
+    } as T;
+    this.records.set(id, tombstone);
+    return true;
+  }
+
+  public async getOneById(id: string, options?: { includeDeleted?: boolean }): Promise<T> {
+    const existing = this.records.get(id);
+    if (!existing) {
+      throw new DataBaseNotFoundError('Record not found');
+    }
+    if (this.options.softDelete && existing.deletedAt && !options?.includeDeleted) {
+      throw new DataBaseNotFoundError('Record not found');
+    }
+    return existing;
+  }
+
+  public async hardDelete(id: string): Promise<boolean> {
+    const existing = this.records.get(id);
+    if (!existing) return false;
+    Object.keys(this.uniqueIndexes).forEach((field) => {
+      const normalized = this.normalizeUniqueValue(field, existing[field]);
+      this.uniqueIndexes[field].delete(normalized);
+    });
+    Object.keys(this.relationIndexes).forEach((field) => {
+      const ref = stringifyPrimitive(existing[field] as Primitive);
+      if (!ref) return;
+      const set = this.relationIndexes[field].get(ref);
+      if (!set) return;
+      set.delete(id);
+      if (set.size === 0) this.relationIndexes[field].delete(ref);
+    });
+    this.records.delete(id);
+    return true;
+  }
+
+  public async create(key: string, value: T): Promise<T> {
+    const { entity, ledger } = this.options;
+    if (entity && ledger?.has(entity, key)) {
+      throw new ConflictError('The field "id" already exists.');
+    }
+    if (this.records.has(key)) {
+      throw new ConflictError('The field "id" already exists.');
+    }
+    this.ensureUniqueIndexes(key, value);
+    this.syncRelationIndexes(key, value);
+    this.records.set(key, value);
+    return value;
+  }
+
+  public async update(key: string, value: T): Promise<T> {
+    const previous = this.records.get(key);
+    if (!previous) {
+      throw new DataBaseNotFoundError('Record not found');
+    }
+    const merged = { ...previous, ...value, updatedAt: new Date() } as T;
+    this.ensureUniqueIndexes(key, merged, previous);
+    this.syncRelationIndexes(key, merged, previous);
+    this.records.set(key, merged);
+    return merged;
+  }
+
+  /**
+   * Filters, search, sort and paging share one implementation with the
+   * external-store proxy (`runListQuery`, JUM-777), so every driver answers
+   * the REST list contract the same way.
+   */
+  public async getAll(
+    filters: Record<string, string | number>,
+    paging: IPagingRequest
+  ): Promise<IPagingResponse<T[]>> {
+    // The contracts' response type marks `page`/`size` optional; `paginateList`
+    // always sets them, so the application's stricter shape holds.
+    const effectivePaging = this.options.softDelete
+      ? paging
+      : { ...paging, includeDeleted: true };
+    return runListQuery(
+      [...this.records.values()],
+      filters,
+      effectivePaging
+    ) as IPagingResponse<T[]>;
+  }
+
+  public async getByRelation(field: keyof T, referenceId: string): Promise<T[]> {
+    const index = this.relationIndexes[field.toString()];
+    if (!index) return [];
+    const linked = index.get(referenceId);
+    if (!linked) return [];
+    return [...linked]
+      .map((id) => this.records.get(id))
+      .filter((entry): entry is T => {
+        if (!entry) return false;
+        if (this.options.softDelete && entry.deletedAt) return false;
+        return true;
+      });
+  }
+}

package/templates/backend/src/infra/persistence/InMemoryDatabase/Stores/OrganizationStoreAPI.ts

@@ -0,0 +1,16 @@
+import type { IStore } from '@src/infra/ports/persistence/IStore';
+import type { IOrganization } from '@src/modules/Users/domain/Entity/IOrganization';
+import { InMemoryRelationalStore } from '@src/infra/persistence/InMemoryDatabase/Stores/InMemoryRelationalStore';
+import { entityIdLedger } from '@src/infra/persistence/InMemoryDatabase/idReservationLedger';
+
+export const OrganizationStoreAPI: IStore<IOrganization> = new InMemoryRelationalStore<
+IOrganization
+>(
+  {
+    uniqueIndexes: ['name'],
+    caseInsensitiveUniqueIndexes: ['name'],
+    softDelete: true,
+    entity: 'Organization',
+    ledger: entityIdLedger
+  }
+);

package/templates/backend/src/infra/persistence/InMemoryDatabase/Stores/UserStoreAPI.ts

@@ -0,0 +1,13 @@
+import type { IStore } from '@src/infra/ports/persistence/IStore';
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import { InMemoryRelationalStore } from '@src/infra/persistence/InMemoryDatabase/Stores/InMemoryRelationalStore';
+import { entityIdLedger } from '@src/infra/persistence/InMemoryDatabase/idReservationLedger';
+
+export const UserStoreAPI: IStore<IUser> = new InMemoryRelationalStore<IUser>({
+  uniqueIndexes: ['username'],
+  caseInsensitiveUniqueIndexes: ['username'],
+  relationIndexes: ['organization'],
+  softDelete: true,
+  entity: 'User',
+  ledger: entityIdLedger
+});

package/templates/backend/src/infra/persistence/InMemoryDatabase/idReservationLedger.ts

@@ -0,0 +1,4 @@
+import { InMemoryIdReservationLedger } from '@jumentix/persistence-contracts';
+
+/** Shared by User and Organization stores in the dev in-memory client. */
+export const entityIdLedger = new InMemoryIdReservationLedger();

package/templates/backend/src/infra/persistence/KeyValueStorage/BaseKeyValueStorageClient.ts

@@ -0,0 +1 @@
+export { BaseKeyValueStorageClient } from '@jumentix/key-value-storage';

package/templates/backend/src/infra/persistence/KeyValueStorage/IKeyValueStorageClient.ts

@@ -0,0 +1 @@
+export type { IKeyValueStorageClient } from '@jumentix/key-value-storage';

package/templates/backend/src/infra/persistence/KeyValueStorage/InMemoryKeyValueStorageClient.ts

@@ -0,0 +1 @@
+export { InMemoryKeyValueStorageClient } from '@jumentix/key-value-storage';

package/templates/backend/src/infra/persistence/KeyValueStorage/RedisKeyValueStorageClient.ts

@@ -0,0 +1 @@
+export { RedisKeyValueStorageClient } from '@jumentix/key-value-storage';

package/templates/backend/src/infra/persistence/KeyValueStorage/compileKeyValueStorageClient.ts

@@ -0,0 +1 @@
+export { compileKeyValueStorageClient } from '@jumentix/key-value-storage';

package/templates/backend/src/infra/persistence/compileDatabaseClient.ts

@@ -0,0 +1,23 @@
+import { buildDatabaseClientCompilers } from '@jumentix/database-client-factory';
+import type { IDatabaseClient } from '@src/infra/persistence/port/IDatabaseClient';
+import { InMemoryDbClient } from '@src/infra/persistence/InMemoryDatabase/InMemoryDbClient';
+
+const compilers = buildDatabaseClientCompilers<IDatabaseClient>({
+  inMemoryClient: InMemoryDbClient
+});
+
+export const {
+  compileDatabaseClient,
+  compileDatabaseClientByDriver,
+  compileMongoDbClient,
+  compilePostgreSqlDbClient,
+  compileMySqlDbClient,
+  compileMsSqlDbClient,
+  compileOracleDbClient,
+  compileSqliteDbClient,
+  compileDynamoDbClient,
+  compileCassandraDbClient,
+  compileFirebaseDbClient,
+  compileAuroraDbClient,
+  compileRdsDbClient
+} = compilers;

package/templates/backend/src/infra/persistence/external/AuroraRepository.ts

@@ -0,0 +1 @@
+export { AuroraRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/BaseExternalDataRepository.ts

@@ -0,0 +1,6 @@
+export type {
+  IRepositoryConnectionOptions
+} from '@jumentix/external-persistence-core';
+export {
+  BaseExternalDataRepository
+} from '@jumentix/external-persistence-core';

package/templates/backend/src/infra/persistence/external/CassandraRepository.ts

@@ -0,0 +1 @@
+export { CassandraRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/DynamoDbRepository.ts

@@ -0,0 +1 @@
+export { DynamoDbRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/ExternalStoreProxy.ts

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export { ExternalStoreProxy, createExternalStores } from '@jumentix/external-store-proxy';

package/templates/backend/src/infra/persistence/external/FirebaseRepository.ts

@@ -0,0 +1 @@
+export { FirebaseRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/MongoMongooseRepository.ts

@@ -0,0 +1 @@
+export { MongoMongooseRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/OracleRepository.ts

@@ -0,0 +1 @@
+export { OracleRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/RdsRepository.ts

@@ -0,0 +1 @@
+export { RdsRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/SqlSequelizeRepository.ts

@@ -0,0 +1,7 @@
+// Split by declaration kind, not by name prefix. `SqlSequelizeRepository` is a
+// class and must stay a runtime re-export; `ESqlDialect` is a `type` alias
+// despite the E prefix, and `ISqlSequelizeRepositoryOptions` is an interface —
+// re-exporting either as a value leaves Bun's ESM runtime looking for a binding
+// that type erasure removed.
+export type { ESqlDialect, ISqlSequelizeRepositoryOptions } from '@jumentix/external-db-repositories';
+export { SqlSequelizeRepository } from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/external/index.ts

@@ -0,0 +1,3 @@
+export * from '@jumentix/external-persistence-core';
+export * from '@jumentix/external-store-proxy';
+export * from '@jumentix/external-db-repositories';

package/templates/backend/src/infra/persistence/port/IDatabaseClient.ts

@@ -0,0 +1,11 @@
+import type { IDatabaseClient as IGenericDatabaseClient, IStore } from '@jumentix/persistence-contracts';
+import type { IUser } from '@src/modules/Users/domain/Entity/IUser';
+import type { IOrganization } from '@src/modules/Users/domain/Entity/IOrganization';
+
+export interface IDbStores {
+    User: IStore<IUser>;
+    Organization: IStore<IOrganization>;
+    [key: string]: IStore<any>;
+}
+
+export interface IDatabaseClient extends IGenericDatabaseClient<IDbStores> {}

package/templates/backend/src/infra/persistence/purgeStores.ts

@@ -0,0 +1,47 @@
+import {
+  purgeTombstones,
+  TOMBSTONE_PURGE_TTL_DAYS,
+  type IIdReservationLedger,
+  type IPurgeReport,
+  type IPurgeStore,
+  type IStore
+} from '@jumentix/persistence-contracts';
+
+export const adaptPurgeStore = (
+  entity: string,
+  store: IStore<Record<string, unknown> & { id: string; deletedAt?: unknown }>
+): IPurgeStore => ({
+  entity,
+  async listTombstones() {
+    const page = await store.getAll({}, { page: 1, size: 10_000, includeDeleted: true });
+    return (page.result || []).filter((row) => row.deletedAt);
+  },
+  async hardDelete(id: string) {
+    if (!store.hardDelete) {
+      throw new Error(`Store ${entity} does not implement hardDelete`);
+    }
+    return store.hardDelete(id);
+  }
+});
+
+export async function purgeUserAndOrganizationTombstones(input: {
+  userStore: IStore<any>;
+  organizationStore: IStore<any>;
+  ledger: IIdReservationLedger;
+  now?: Date;
+  olderThanDays?: number;
+  commit?: boolean;
+  excludeIds?: string[];
+}): Promise<IPurgeReport> {
+  return purgeTombstones({
+    stores: [
+      adaptPurgeStore('Organization', input.organizationStore),
+      adaptPurgeStore('User', input.userStore)
+    ],
+    ledger: input.ledger,
+    now: input.now,
+    olderThanDays: input.olderThanDays ?? TOMBSTONE_PURGE_TTL_DAYS,
+    commit: input.commit === true,
+    excludeIds: input.excludeIds
+  });
+}

package/templates/backend/src/infra/ports/persistence/IStore.ts

@@ -0,0 +1 @@
+export * from '@jumentix/persistence-contracts';

package/templates/backend/src/infra/security/IPasswordCryptoService.ts

@@ -0,0 +1,28 @@
+export interface IHash {
+  hash: string;
+  salt: string;
+}
+
+export interface IPasswordCryptoService {
+  hash(password: string): Promise<IHash>;
+  compare(plainPassword: string, hash: string): Promise<boolean>;
+}
+
+/**
+ * The part of `bcryptjs` this service uses.
+ *
+ * Declared as a port so the error branches can be driven directly. They were
+ * previously reached by replacing the `bcryptjs` module at runtime, which is not
+ * portable: `jest.doMock` does not exist under Bun's runner, and `spyOn` against
+ * an ESM namespace works under Bun but is rejected by Jest as an assignment to a
+ * read-only property. A suite that has to pick a runner is a suite that stops
+ * running on the other one (JUM-583).
+ *
+ * bcryptjs@3 exposes a Promise-based async API (callbacks were removed). The
+ * port matches that surface so the production default remains a thin wrap.
+ */
+export interface IPasswordHasher {
+  genSalt(rounds: number): Promise<string>;
+  hash(password: string, salt: string): Promise<string>;
+  compare(plainPassword: string, hash: string): Promise<boolean>;
+}

package/templates/backend/src/infra/security/PasswordCryptoService.ts

@@ -0,0 +1,51 @@
+import bcrypt from 'bcryptjs';
+import { _BCRYPT_SALT_ROUNDS_ } from '@src/config/constants';
+import type { IPasswordCryptoService, IHash, IPasswordHasher } from './IPasswordCryptoService';
+
+let passwordCryptoService: IPasswordCryptoService;
+
+export class PasswordCryptoService implements IPasswordCryptoService {
+  private saltRounds: number;
+
+  private hasher: IPasswordHasher;
+
+  /**
+   * @param hasher Defaults to `bcryptjs`. Injected only so the error branches
+   * are reachable without replacing the module at runtime — see IPasswordHasher.
+   */
+  constructor(hasher: IPasswordHasher = bcrypt as unknown as IPasswordHasher) {
+    this.saltRounds = +(_BCRYPT_SALT_ROUNDS_);
+    this.hasher = hasher;
+  }
+
+  public async hash(password: string): Promise<IHash> {
+    const salt = await this.hasher.genSalt(this.saltRounds);
+    // A resolved value of `undefined` should not happen, and the previous cast
+    // to IHash made it resolve with `undefined` if it ever did — a stored
+    // "password hash" of undefined, reported as success. Rejecting keeps the
+    // failure where it happened.
+    if (salt === undefined) {
+      throw new Error('password hasher returned no salt and no error');
+    }
+    const hash = await this.hasher.hash(password, salt);
+    if (hash === undefined) {
+      throw new Error('password hasher returned no hash and no error');
+    }
+    return { hash, salt };
+  }
+
+  public async compare(plainPassword: string, hash: string): Promise<boolean> {
+    const result = await this.hasher.compare(plainPassword, hash);
+    // Defaulting to `false` rather than resolving `undefined`: a missing
+    // result is not a match, and a caller writing `if (await compare(...))`
+    // would have treated `undefined` as a rejection anyway — but a caller
+    // writing `=== false` would not have.
+    return result ?? false;
+  }
+
+  public static compile() {
+    if (passwordCryptoService) return passwordCryptoService;
+    passwordCryptoService = new PasswordCryptoService();
+    return passwordCryptoService;
+  }
+}

package/templates/backend/src/infra/security/index.ts

@@ -0,0 +1,7 @@
+import xss from 'xss';
+
+export class Security {
+  public static xss(str: string): string {
+    return xss(str);
+  }
+}