@solid-stack/mason 1.0.27 → 1.0.30

package/templates/httpHandler/handler.hbs

@@ -11,61 +11,61 @@ import { {{ucName}} } from "../../useCases/{{ucName}}.js";
 export type HttpResponseStatus = "info" | "success" | "redirect" | "fail" | "error";
 
 export interface HttpResponse<T = object> {
-  status: HttpResponseStatus;
-  message: string;
-  data?: T;
+	status: HttpResponseStatus;
+	message: string;
+	data?: T;
 }
 
 {{#if includeValidation}}
 const {{schemaName}} = z.object({
 {{#if hasValidationFields}}
 {{#each validationFields}}
-  {{name}}: {{{zodType}}},
+	{{name}}: {{{zodType}}},
 {{/each}}
 {{else}}
-  // TODO: define schema properties
-  example: z.string().optional(),
+	// TODO: define schema properties
+	example: z.string().optional(),
 {{/if}}
 });
 
 {{/if}}
 @MakeInjectable
 export default class {{className}} extends ExpressRoute {
-  public static deps = {
+	public static deps = {
 {{#if ucName}}
-    {{ucDepKey}}: {{ucName}},
+		{{ucDepKey}}: {{ucName}},
 {{/if}}
-  };
+	};
 
-  constructor(public deps: DepsType<typeof {{className}}.deps>) {
-    super();
-  }
+	constructor(public deps: DepsType<typeof {{className}}.deps>) {
+		super();
+	}
 
-  public method = "{{method}}" as const;
-  public path = "{{routeSubPath}}";
-  public handler = async (req: Request, res: Response) => {
+	public method = "{{method}}" as const;
+	public path = "{{routeSubPath}}";
+	public handler = async (req: Request, res: Response) => {
 {{#if includeValidation}}
-    const parsed = {{schemaName}}.safeParse(req.{{validationSource}});
-    if (!parsed.success) {
-      return res.status(400).json({
-        status: "error",
-        message: "Validation failed",
-        data: parsed.error.format(),
-      });
-    }
+		const parsed = {{schemaName}}.safeParse(req.{{validationSource}});
+		if (!parsed.success) {
+			return res.status(400).json({
+				status: "error",
+				message: "Validation failed",
+				data: parsed.error.format(),
+			});
+		}
 {{/if}}
 {{#if ucName}}
-    const result = await this.deps.{{ucDepKey}}.execute({{callArg}});
-    return res.status({{statusCode}}).json({
-      status: "success",
-      message: "{{successMessage}}",
-      data: result,
-    });
+		const result = await this.deps.{{ucDepKey}}.execute({{callArg}});
+		return res.status({{statusCode}}).json({
+			status: "success",
+			message: "{{successMessage}}",
+			data: result,
+		});
 {{else}}
-    return res.status(200).json({
-      status: "success",
-      message: "{{successMessage}}",
-    });
+		return res.status(200).json({
+			status: "success",
+			message: "{{successMessage}}",
+		});
 {{/if}}
-  };
+	};
 }

package/templates/infra/concrete.hbs

@@ -8,22 +8,22 @@ import {{#if isTypeOnly}}type {{/if}}{ {{names}} } from "{{from}}";
 
 @MakeInjectable
 export class {{className}}{{#if ifaceName}} implements {{ifaceName}}{{/if}} {
-  public static deps = {
+	public static deps = {
 {{#each dependencies}}
-    {{key}}: {{name}},
+		{{key}}: {{name}},
 {{/each}}
-  };
+	};
 
-  constructor(public deps: DepsType<typeof {{className}}.deps>) {}
+	constructor(public deps: DepsType<typeof {{className}}.deps>) {}
 {{#if hasMethods}}
 {{#each methods}}
 
-  {{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
-    throw new Error("not implemented");
-  }
+	{{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
+		throw new Error("not implemented");
+	}
 {{/each}}
 {{else}}
 
-  // Implement your infrastructure methods here
+	// Implement your infrastructure methods here
 {{/if}}
 }

package/templates/infra/stub.hbs

@@ -9,95 +9,95 @@ import {{#if isTypeOnly}}type {{/if}}{ {{names}} } from "{{from}}";
 
 @MakeInjectable
 export class {{stubClassName}} implements {{ifaceName}} {
-  public static deps = {};
+	public static deps = {};
 {{#if baseEntity}}
 
-  private {{entitiesVar}}: Map<string, {{baseEntity}}> = new Map();
-  private errorToThrow: Error | null = null;
-
-  constructor(public deps: DepsType<typeof {{stubClassName}}.deps>) {}
-
-  // --- Test Helpers ---
-  public clear(): void {
-    this.{{entitiesVar}}.clear();
-    this.errorToThrow = null;
-  }
-
-  public add{{baseEntity}}({{entityVar}}: {{baseEntity}}): void {
-    this.{{entitiesVar}}.set({{entityVar}}.id, { ...{{entityVar}} });
-  }
-
-  public get{{baseEntity}}s(): {{baseEntity}}[] {
-    return Array.from(this.{{entitiesVar}}.values()).map((e) => ({ ...e }));
-  }
-
-  public setError(error: Error | null): void {
-    this.errorToThrow = error;
-  }
-
-  // --- {{ifaceName}} Methods ---
-  async Get{{baseEntity}}ById(input: { {{idKey}}: string }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
-    if (this.errorToThrow) throw this.errorToThrow;
-    const found = this.{{entitiesVar}}.get(input.{{idKey}});
-    if (!found) throw new Error("{{baseEntity}} with ID " + input.{{idKey}} + " not found");
-    return { {{entityVar}}: { ...found } };
-  }
-
-  async List{{baseEntity}}s(input?: { page?: number | undefined; limit?: number | undefined }): Promise<{ {{entitiesVar}}: {{baseEntity}}[]; total?: number | undefined; page?: number | undefined; limit?: number | undefined }> {
-    if (this.errorToThrow) throw this.errorToThrow;
-    let all = this.get{{baseEntity}}s();
-    const total = all.length;
-    if (input?.page && input?.limit) {
-      const start = (input.page - 1) * input.limit;
-      all = all.slice(start, start + input.limit);
-      return { {{entitiesVar}}: all, total, page: input.page, limit: input.limit };
-    }
-    return { {{entitiesVar}}: all, total };
-  }
-
-  async Create{{baseEntity}}(input: { {{entityVar}}: {{baseEntity}} }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
-    if (this.errorToThrow) throw this.errorToThrow;
-    const entity = { ...input.{{entityVar}} };
-    this.{{entitiesVar}}.set(entity.id, entity);
-    return { {{entityVar}}: { ...entity } };
-  }
-
-  async Update{{baseEntity}}(input: { {{entityVar}}: {{baseEntity}} }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
-    if (this.errorToThrow) throw this.errorToThrow;
-    if (!this.{{entitiesVar}}.has(input.{{entityVar}}.id)) {
-      throw new Error("{{baseEntity}} with ID " + input.{{entityVar}}.id + " not found");
-    }
-    const entity = { ...input.{{entityVar}} };
-    this.{{entitiesVar}}.set(entity.id, entity);
-    return { {{entityVar}}: { ...entity } };
-  }
-
-  async Delete{{baseEntity}}(input: { {{idKey}}: string }): Promise<{ success: boolean }> {
-    if (this.errorToThrow) throw this.errorToThrow;
-    this.{{entitiesVar}}.delete(input.{{idKey}});
-    return { success: true };
-  }
+	private {{entitiesVar}}: Map<string, {{baseEntity}}> = new Map();
+	private errorToThrow: Error | null = null;
+
+	constructor(public deps: DepsType<typeof {{stubClassName}}.deps>) {}
+
+	// --- Test Helpers ---
+	public clear(): void {
+		this.{{entitiesVar}}.clear();
+		this.errorToThrow = null;
+	}
+
+	public add{{baseEntity}}({{entityVar}}: {{baseEntity}}): void {
+		this.{{entitiesVar}}.set({{entityVar}}.id, { ...{{entityVar}} });
+	}
+
+	public get{{baseEntity}}s(): {{baseEntity}}[] {
+		return Array.from(this.{{entitiesVar}}.values()).map((e) => ({ ...e }));
+	}
+
+	public setError(error: Error | null): void {
+		this.errorToThrow = error;
+	}
+
+	// --- {{ifaceName}} Methods ---
+	async Get{{baseEntity}}ById(input: { {{idKey}}: string }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
+		if (this.errorToThrow) throw this.errorToThrow;
+		const found = this.{{entitiesVar}}.get(input.{{idKey}});
+		if (!found) throw new Error("{{baseEntity}} with ID " + input.{{idKey}} + " not found");
+		return { {{entityVar}}: { ...found } };
+	}
+
+	async List{{baseEntity}}s(input?: { page?: number | undefined; limit?: number | undefined }): Promise<{ {{entitiesVar}}: {{baseEntity}}[]; total?: number | undefined; page?: number | undefined; limit?: number | undefined }> {
+		if (this.errorToThrow) throw this.errorToThrow;
+		let all = this.get{{baseEntity}}s();
+		const total = all.length;
+		if (input?.page && input?.limit) {
+			const start = (input.page - 1) * input.limit;
+			all = all.slice(start, start + input.limit);
+			return { {{entitiesVar}}: all, total, page: input.page, limit: input.limit };
+		}
+		return { {{entitiesVar}}: all, total };
+	}
+
+	async Create{{baseEntity}}(input: { {{entityVar}}: {{baseEntity}} }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
+		if (this.errorToThrow) throw this.errorToThrow;
+		const entity = { ...input.{{entityVar}} };
+		this.{{entitiesVar}}.set(entity.id, entity);
+		return { {{entityVar}}: { ...entity } };
+	}
+
+	async Update{{baseEntity}}(input: { {{entityVar}}: {{baseEntity}} }): Promise<{ {{entityVar}}: {{baseEntity}} }> {
+		if (this.errorToThrow) throw this.errorToThrow;
+		if (!this.{{entitiesVar}}.has(input.{{entityVar}}.id)) {
+			throw new Error("{{baseEntity}} with ID " + input.{{entityVar}}.id + " not found");
+		}
+		const entity = { ...input.{{entityVar}} };
+		this.{{entitiesVar}}.set(entity.id, entity);
+		return { {{entityVar}}: { ...entity } };
+	}
+
+	async Delete{{baseEntity}}(input: { {{idKey}}: string }): Promise<{ success: boolean }> {
+		if (this.errorToThrow) throw this.errorToThrow;
+		this.{{entitiesVar}}.delete(input.{{idKey}});
+		return { success: true };
+	}
 {{#each extraMethods}}
 
-  {{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
-    throw new Error("not implemented");
-  }
+	{{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
+		throw new Error("not implemented");
+	}
 {{/each}}
 {{else}}
 
-  constructor(public deps: DepsType<typeof {{stubClassName}}.deps>) {}
+	constructor(public deps: DepsType<typeof {{stubClassName}}.deps>) {}
 {{#if hasMethods}}
 {{#each methods}}
 
-  {{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
-    throw new Error("not implemented");
-  }
+	{{#if isAsync}}async {{/if}}{{name}}{{{typeParams}}}({{{params}}}): {{{returnType}}} {
+		throw new Error("not implemented");
+	}
 {{/each}}
 {{else}}
 
-  async execute(input?: unknown): Promise<unknown> {
-    throw new Error("{{stubClassName}}.execute not implemented");
-  }
+	async execute(input?: unknown): Promise<unknown> {
+		throw new Error("{{stubClassName}}.execute not implemented");
+	}
 {{/if}}
 {{/if}}
 }

package/templates/injectable/injectable.hbs

@@ -5,28 +5,28 @@ import { {{implementsInterface}} } from "./{{implementsInterface}}.js";
 
 @MakeInjectable
 export class {{className}}{{#if implementsInterface}} implements {{implementsInterface}}{{/if}} {
-  public static deps = {
+	public static deps = {
 {{#each dependencies}}
-    {{key}}: {{name}},
+		{{key}}: {{name}},
 {{/each}}
-  };
+	};
 
 {{#if hasDependencies}}
-  constructor(public deps: DepsType<typeof {{className}}.deps>) {}
+	constructor(public deps: DepsType<typeof {{className}}.deps>) {}
 {{else}}
-  constructor() {}
+	constructor() {}
 {{/if}}
 
 {{#if hasMethods}}
 {{#each methods}}
-  public {{#if isAsync}}async {{/if}}{{name}}({{{params}}}): {{{returnType}}} {
-    // TODO: implement method logic
-  }
+	public {{#if isAsync}}async {{/if}}{{name}}({{{params}}}): {{{returnType}}} {
+		// TODO: implement method logic
+	}
 
 {{/each}}
 {{else}}
-  public execute(): void {
-    // TODO: implement logic
-  }
+	public execute(): void {
+		// TODO: implement logic
+	}
 {{/if}}
 }

package/templates/injectable/interface.hbs

@@ -1,3 +1,3 @@
 export abstract class {{ifaceName}} {
-  abstract execute(): void;
+	abstract execute(): void;
 }

package/templates/interface/interface.hbs

@@ -4,16 +4,16 @@ import type { {{domainImport}} } from "./{{domainImport}}.js";
 {{/if}}
 export {{#if isAbstractClass}}abstract class{{else}}interface{{/if}} {{ifaceName}} {
 {{#if isCrud}}
-  {{methodPrefix}}Get{{baseEntity}}ById(input: { {{idKey}}: string }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
-  {{methodPrefix}}List{{baseEntity}}s(input?: { page?: number | undefined; limit?: number | undefined }): Promise<{ {{listKey}}: {{baseEntity}}[]; total?: number | undefined; page?: number | undefined; limit?: number | undefined }>;
-  {{methodPrefix}}Create{{baseEntity}}(input: { {{entityKey}}: {{baseEntity}} }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
-  {{methodPrefix}}Update{{baseEntity}}(input: { {{entityKey}}: {{baseEntity}} }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
-  {{methodPrefix}}Delete{{baseEntity}}(input: { {{idKey}}: string }): Promise<{ success: boolean }>;
+	{{methodPrefix}}Get{{baseEntity}}ById(input: { {{idKey}}: string }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
+	{{methodPrefix}}List{{baseEntity}}s(input?: { page?: number | undefined; limit?: number | undefined }): Promise<{ {{listKey}}: {{baseEntity}}[]; total?: number | undefined; page?: number | undefined; limit?: number | undefined }>;
+	{{methodPrefix}}Create{{baseEntity}}(input: { {{entityKey}}: {{baseEntity}} }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
+	{{methodPrefix}}Update{{baseEntity}}(input: { {{entityKey}}: {{baseEntity}} }): Promise<{ {{entityKey}}: {{baseEntity}} }>;
+	{{methodPrefix}}Delete{{baseEntity}}(input: { {{idKey}}: string }): Promise<{ success: boolean }>;
 {{else if isCustom}}
 {{#each customMethods}}
-  {{../methodPrefix}}{{name}}({{#if params}}input: { {{params}} }{{/if}}): {{returnType}};
+	{{../methodPrefix}}{{name}}({{#if params}}input: { {{params}} }{{/if}}): {{returnType}};
 {{/each}}
 {{else}}
-  {{methodPrefix}}execute(input?: unknown): Promise<unknown>;
+	{{methodPrefix}}execute(input?: unknown): Promise<unknown>;
 {{/if}}
 }

package/templates/provider/provider.hbs

@@ -6,7 +6,7 @@ import { {{implName}} } from "{{implImportPath}}";
 
 export const {{providerModuleName}}: DIModule = (c: Container) => {
 {{#each bindings}}
-  c.provide({{ifaceName}}, {{implName}});
+	c.provide({{ifaceName}}, {{implName}});
 {{/each}}
 };
 

package/templates/useCase/useCase.hbs

@@ -9,7 +9,7 @@ import type { {{this}} } from "../domain/{{this}}.js";
 {{#if hasInputProps}}
 export type {{inputTypeName}} = {
 {{#each inputProperties}}
-  {{name}}{{#if optional}}?{{/if}}: {{type}};
+	{{name}}{{#if optional}}?{{/if}}: {{type}};
 {{/each}}
 };
 {{else}}
@@ -19,39 +19,39 @@ export type {{inputTypeName}} = Record<string, never>;
 {{#if hasOutputProps}}
 export type {{outputTypeName}} = {
 {{#each outputProperties}}
-  {{name}}{{#if optional}}?{{/if}}: {{type}};
+	{{name}}{{#if optional}}?{{/if}}: {{type}};
 {{/each}}
 };
 {{else}}
 export type {{outputTypeName}} = {
-  success: boolean;
+	success: boolean;
 };
 {{/if}}
 
 @MakeInjectable
 export class {{ucName}} {
-  public static deps = {
+	public static deps = {
 {{#each dependencies}}
-    {{key}}: {{name}},
+		{{key}}: {{name}},
 {{/each}}
-  };
+	};
 
 {{#if hasDependencies}}
-  constructor(public deps: DepsType<typeof {{ucName}}.deps>) {}
+	constructor(public deps: DepsType<typeof {{ucName}}.deps>) {}
 {{else}}
-  constructor() {}
+	constructor() {}
 {{/if}}
 
-  async execute({{paramStr}}): Promise<{{outputTypeName}}> {
+	async execute({{paramStr}}): Promise<{{outputTypeName}}> {
 {{#if callWired}}
 {{{callWired}}}
 {{else}}
-    // TODO: Implement use case business logic
+		// TODO: Implement use case business logic
 {{#if hasOutputProps}}
-    throw new Error("{{ucName}} not implemented");
+		throw new Error("{{ucName}} not implemented");
 {{else}}
-    return { success: true };
+		return { success: true };
 {{/if}}
 {{/if}}
-  }
+	}
 }

package/templates/useCase/useCaseTest.hbs

@@ -7,18 +7,18 @@ import { {{stub}} } from "../infrastructure/{{stub}}.js";
 {{/each}}
 
 describe("{{ucName}} Use Case", () => {
-  let container: Container;
-  let useCase: {{ucName}};
+	let container: Container;
+	let useCase: {{ucName}};
 
-  beforeEach(() => {
-    container = new Container();
+	beforeEach(() => {
+		container = new Container();
 {{#each stubBindings}}
-    container.provide({{iface}}, {{stub}});
+		container.provide({{iface}}, {{stub}});
 {{/each}}
-    useCase = container.resolve({{ucName}});
-  });
+		useCase = container.resolve({{ucName}});
+	});
 
-  it("should be successfully resolved from DI container", () => {
-    expect(useCase).toBeDefined();
-  });
+	it("should be successfully resolved from DI container", () => {
+		expect(useCase).toBeDefined();
+	});
 });