Refactor to use string IDs for executables #262

This commit unifies the concepts of executables having same ID
structure. It paves the way for more complex ID structure and using IDs
in collection files as part of new ID solution (#262). Using string IDs
also leads to more expressive test code.

This commit also refactors the rest of the code to adopt to the changes.

This commit:

- Separate concerns from entities for data access (in repositories) and
  executables. Executables use `Identifiable` meanwhile repositories use
  `RepositoryEntity`.
- Refactor unnecessary generic parameters for enttities and ids,
  enforcing string gtype everwyhere.
- Changes numeric IDs to string IDs for categories to unify the
  retrieval and construction for executables, using pseudo-ids (their
  names) just like scripts.
- Remove `BaseEntity` for simplicity.
- Simplify usage and construction of executable objects.
  Move factories responsible for creation of category/scripts to domain
  layer. Do not longer export `CollectionCategorY` and
  `CollectionScript`.
- Use named typed for string IDs for better differentation of different
  ID contexts in code.

src/domain/Executables/Category/Category.ts

@@ -1,10 +1,9 @@
 import type { Script } from '../Script/Script';
 import type { Executable } from '../Executable';
 
-export interface Category extends Executable<number> {
-  readonly id: number;
+export interface Category extends Executable {
   readonly name: string;
-  readonly subCategories: ReadonlyArray<Category>;
+  readonly subcategories: ReadonlyArray<Category>;
   readonly scripts: ReadonlyArray<Script>;
   includes(script: Script): boolean;
   getAllScriptsRecursively(): ReadonlyArray<Script>;

src/domain/Executables/Category/CategoryFactory.ts

@@ -1,29 +1,51 @@
-import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
-import type { Category } from './Category';
-import type { Script } from '../Script/Script';
+import type { Category } from '@/domain/Executables/Category/Category';
+import type { Script } from '@/domain/Executables/Script/Script';
+import type { ExecutableId } from '../Identifiable';
 
-export class CollectionCategory extends BaseEntity<number> implements Category {
-  private allSubScripts?: ReadonlyArray<Script> = undefined;
+export type CategoryFactory = (
+  parameters: CategoryInitParameters,
+) => Category;
+
+export interface CategoryInitParameters {
+  readonly executableId: ExecutableId;
+  readonly name: string;
+  readonly docs: ReadonlyArray<string>;
+  readonly subcategories: ReadonlyArray<Category>;
+  readonly scripts: ReadonlyArray<Script>;
+}
+
+export const createCategory: CategoryFactory = (
+  parameters,
+) => {
+  return new CollectionCategory(parameters);
+};
+
+class CollectionCategory implements Category {
+  public readonly executableId: ExecutableId;
 
   public readonly name: string;
 
   public readonly docs: ReadonlyArray<string>;
 
-  public readonly subCategories: ReadonlyArray<Category>;
+  public readonly subcategories: ReadonlyArray<Category>;
 
   public readonly scripts: ReadonlyArray<Script>;
 
+  private allSubScripts?: ReadonlyArray<Script> = undefined;
+
   constructor(parameters: CategoryInitParameters) {
-    super(parameters.id);
     validateParameters(parameters);
+    this.executableId = parameters.executableId;
     this.name = parameters.name;
     this.docs = parameters.docs;
-    this.subCategories = parameters.subcategories;
+    this.subcategories = parameters.subcategories;
     this.scripts = parameters.scripts;
   }
 
   public includes(script: Script): boolean {
-    return this.getAllScriptsRecursively().some((childScript) => childScript.id === script.id);
+    return this
+      .getAllScriptsRecursively()
+      .some((childScript) => childScript.executableId === script.executableId);
   }
 
   public getAllScriptsRecursively(): readonly Script[] {
@@ -34,22 +56,17 @@ export class CollectionCategory extends BaseEntity<number> implements Category {
   }
 }
 
-export interface CategoryInitParameters {
-  readonly id: number;
-  readonly name: string;
-  readonly docs: ReadonlyArray<string>;
-  readonly subcategories: ReadonlyArray<Category>;
-  readonly scripts: ReadonlyArray<Script>;
-}
-
 function parseScriptsRecursively(category: Category): ReadonlyArray<Script> {
   return [
     ...category.scripts,
-    ...category.subCategories.flatMap((c) => c.getAllScriptsRecursively()),
+    ...category.subcategories.flatMap((c) => c.getAllScriptsRecursively()),
   ];
 }
 
 function validateParameters(parameters: CategoryInitParameters) {
+  if (!parameters.executableId) {
+    throw new Error('missing ID');
+  }
   if (!parameters.name) {
     throw new Error('missing name');
   }

src/domain/Executables/Executable.ts

@@ -1,6 +1,6 @@
-import type { IEntity } from '@/infrastructure/Entity/IEntity';
 import type { Documentable } from './Documentable';
+import type { Identifiable } from './Identifiable';
 
-export interface Executable<TExecutableKey>
-  extends Documentable, IEntity<TExecutableKey> {
+export interface Executable
+  extends Documentable, Identifiable {
 }

src/domain/Executables/Identifiable.ts

@@ -0,0 +1,5 @@
+export type ExecutableId = string;
+
+export interface Identifiable {
+  readonly executableId: ExecutableId;
+}

src/domain/Executables/Script/Script.ts

@@ -3,7 +3,7 @@ import type { Executable } from '../Executable';
 import type { Documentable } from '../Documentable';
 import type { ScriptCode } from './Code/ScriptCode';
 
-export interface Script extends Executable<string>, Documentable {
+export interface Script extends Executable, Documentable {
   readonly name: string;
   readonly level?: RecommendationLevel;
   readonly code: ScriptCode;

src/domain/Executables/Script/ScriptFactory.ts

@@ -1,9 +1,26 @@
-import { BaseEntity } from '@/infrastructure/Entity/BaseEntity';
 import { RecommendationLevel } from './RecommendationLevel';
-import type { Script } from './Script';
 import type { ScriptCode } from './Code/ScriptCode';
+import type { Script } from './Script';
+
+export interface ScriptInitParameters {
+  readonly executableId: string;
+  readonly name: string;
+  readonly code: ScriptCode;
+  readonly docs: ReadonlyArray<string>;
+  readonly level?: RecommendationLevel;
+}
+
+export type ScriptFactory = (
+  parameters: ScriptInitParameters,
+) => Script;
+
+export const createScript: ScriptFactory = (parameters) => {
+  return new CollectionScript(parameters);
+};
+
+class CollectionScript implements Script {
+  public readonly executableId: string;
 
-export class CollectionScript extends BaseEntity<string> implements Script {
   public readonly name: string;
 
   public readonly code: ScriptCode;
@@ -13,7 +30,7 @@ export class CollectionScript extends BaseEntity<string> implements Script {
   public readonly level?: RecommendationLevel;
 
   constructor(parameters: ScriptInitParameters) {
-    super(parameters.name);
+    this.executableId = parameters.executableId;
     this.name = parameters.name;
     this.code = parameters.code;
     this.docs = parameters.docs;
@@ -26,13 +43,6 @@ export class CollectionScript extends BaseEntity<string> implements Script {
   }
 }
 
-export interface ScriptInitParameters {
-  readonly name: string;
-  readonly code: ScriptCode;
-  readonly docs: ReadonlyArray<string>;
-  readonly level?: RecommendationLevel;
-}
-
 function validateLevel(level?: RecommendationLevel) {
   if (level !== undefined && !(level in RecommendationLevel)) {
     throw new Error(`invalid level: ${level}`);