fix typing issues

Author: icebob

template/.gitignore

@@ -62,3 +62,9 @@ typings/
 
 # JetBrains IDE
 .idea
+
+# Built files
+dist
+
+# Data folder
+data

template/mixins/db.mixin.ts

@@ -1,14 +1,14 @@
 import type { Context, Service, ServiceSchema } from "moleculer";
-
+import type { DatabaseMethods } from "../moleculer-types.js";
 import { Service as DbService } from "@moleculer/database";
 
 export type DbServiceMethods = {
-	seedDb?(): Promise<void>;
+	seedDB?(): Promise<void>;
 };
 
 type DbServiceSchema = Partial<ServiceSchema>;
 
-export type DbServiceThis = Service & DbServiceMethods;
+export type DbServiceThis = Service & DbServiceMethods & DatabaseMethods;
 
 export default function (collection: string): DbServiceSchema {
 	const cacheCleanEventName = `cache.clean.${collection}`;

template/moleculer-types.d.ts

@@ -0,0 +1,60 @@
+import "moleculer";
+
+declare module "moleculer" {
+	interface ActionSchema {
+		graphql?: {
+			query?: string;
+			mutation?: string;
+		};
+
+		auth?: "required" | null | undefined;
+	}
+
+	interface ServiceBroker {
+		sendToChannel(channelName: string, payload: unknown, opts?: { ctx?: Context });
+	}
+
+	interface ServiceSchema {
+		channels?: {
+			[key: string]: {
+				context?: boolean;
+				handler: (this: Service, ctx: Context<P, M, L, H>) => Promise<void>;
+			};
+		};
+	}
+}
+
+interface ApolloServiceSettings {
+	graphql?: {
+		type?: string;
+	};
+}
+
+interface DatabaseSettings {
+	fields: {
+		[key: string]: {
+			type: string;
+			primaryKey?: boolean;
+			columnName?: string;
+			required?: boolean;
+			min?: number;
+			max?: number;
+		}
+	}
+}
+
+interface DatabaseAdapter {
+	findById<TEntity>(id: string): Promise<TEntity>;
+	count(): Promise<number>;
+	insertMany<TEntity>(entities: TEntity[]): Promise<TEntity[]>;
+}
+
+interface DatabaseMethods {
+	getAdapter(ctx?: Context): Promise<DatabaseAdapter>;
+	updateEntity<TEntity>(ctx: Context, entity: Partial<TEntity>): Promise<TEntity>;
+}
+
+
+declare module '@moleculer/database' {
+	export function Service(options?: object): ServiceSchema;
+}

template/package.json

@@ -2,7 +2,7 @@
   "name": "{{projectName}}",
   "version": "1.0.0",
   "description": "My Moleculer-based microservices project",
-  "type": "module",
+  "type": "commonjs",
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "dev": "tsx ./node_modules/moleculer/bin/moleculer-runner.js --config moleculer.config.ts --hot --repl services/**/*.service.ts",

template/services/api.service.ts

@@ -1,8 +1,7 @@
 import type { Context, ServiceSchema } from "moleculer";
-import type { IncomingMessage, ServerResponse } from "http";
 
 import ApiGateway from "moleculer-web";
-import type { ApiSettingsSchema } from "moleculer-web";
+import type { ApiSettingsSchema, Route, IncomingRequest, GatewayResponse } from "moleculer-web";
 {{#apiIO}}
 import SocketIOService from "moleculer-io";
 {{/apiIO}}
@@ -11,9 +10,14 @@ import { ApolloService } from "moleculer-apollo-server";
 import { GraphQLJSONObject } from "graphql-type-json";
 {{/apiGQL}}
 
+interface MetaUser {
+	id: number;
+	name: string;
+}
+
 interface Meta {
 	userAgent?: string | null | undefined;
-	user?: object | null | undefined;
+	user?: MetaUser | null | undefined;
 }
 
 const ApiService: ServiceSchema<ApiSettingsSchema> = {
@@ -50,7 +54,7 @@ const ApiService: ServiceSchema<ApiSettingsSchema> = {
 	/** More info: https://moleculer.services/docs/0.15/moleculer-web.html */
 	settings: {
 		// Exposed port
-		port: process.env.PORT || 3000,
+		port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
 
 		// Exposed IP
 		ip: "0.0.0.0",
@@ -88,7 +92,7 @@ const ApiService: ServiceSchema<ApiSettingsSchema> = {
 				onBeforeCall(
 					ctx: Context<unknown, Meta>,
 					route: Route,
-					req: IncomingMessage,
+					req: IncomingRequest,
 					res: GatewayResponse,
 				): void {
 					// Set request headers to context meta
@@ -101,7 +105,7 @@ const ApiService: ServiceSchema<ApiSettingsSchema> = {
 				onAfterCall(
 					ctx: Context,
 					route: Route,
-					req: IncomingMessage,
+					req: IncomingRequest,
 					res: GatewayResponse,
 					data: unknown,
 				): unknown {
@@ -163,8 +167,8 @@ const ApiService: ServiceSchema<ApiSettingsSchema> = {
 		authenticate(
 			ctx: Context,
 			route: Route,
-			req: IncomingMessage,
-		): Record<string, unknown> | null {
+			req: IncomingRequest,
+		): MetaUser | null {
 			// Read the token from header
 			const auth = req.headers["authorization"];
 
@@ -193,7 +197,7 @@ const ApiService: ServiceSchema<ApiSettingsSchema> = {
 		 *
 		 * PLEASE NOTE, IT'S JUST AN EXAMPLE IMPLEMENTATION. DO NOT USE IN PRODUCTION!
 		 */
-		authorize(ctx: Context<null, Meta>, route: Route, req: IncomingMessage) {
+		authorize(ctx: Context<null, Meta>, route: Route, req: IncomingRequest) {
 			// Get the authenticated user.
 			const user = ctx.meta.user;
 

template/services/inventory.service.ts

@@ -14,9 +14,9 @@ const InventoryService: ServiceSchema = {
 		 */
 		"inventory.reserve": {
 			context: true,
-			async handler(ctx: Context) {
+			async handler(this: Service, ctx: Context<{ productId: string; quantity: number }>) {
 				// Simulate external API call to reserve the quantity...
-				await this.Promise.delay(1000);
+				await new Promise(resolve => setTimeout(resolve, 1000));
 
 				this.logger.info(
 					`Reserve ${ctx.params.quantity} pieces of the ${ctx.params.productId} product in the inventory.`
@@ -46,7 +46,7 @@ const InventoryService: ServiceSchema = {
 				productId: { type: "string" },
 				quantity: { type: "number" }
 			},
-			async handler(ctx: Context) {
+			async handler(ctx: Context<{ productId: string; quantity: number }>) {
 				await this.broker.sendToChannel(
 					"inventory.reserve",
 					{

template/services/orders.service.ts

@@ -1,5 +1,18 @@
 import type { Context, Service, ServiceSchema, ServiceSettingSchema } from "moleculer";
 
+interface WorkflowPayload {
+	card?: string;
+	amount?: number;
+	productId?: string;
+	quantity?: number;
+	address?: string;
+}
+
+interface PaymentResult {
+	status: "wait" | "success" | "failed";
+	transactionId: string;
+}
+
 const OrdersService: ServiceSchema = {
 	name: "orders",
 
@@ -8,10 +21,10 @@ const OrdersService: ServiceSchema = {
 	 */
 	workflows: {
 		process: {
-			async handler(ctx: Context) {
-				this.logger.info("Start processing order", ctx.params);
+			async handler(this: Service, ctx: Context<WorkflowPayload>) {
+				this.logger.info("Start processing order. Job ID:", ctx.wf.jobId, ctx.params);
 
-				const paymentResult = await ctx.call("orders.payment", {
+				const paymentResult = await ctx.call<PaymentResult, Partial<WorkflowPayload>>("orders.payment", {
 					card: ctx.params.card,
 					amount: ctx.params.amount
 				});
@@ -76,7 +89,7 @@ const OrdersService: ServiceSchema = {
 				card: { type: "string" },
 				amount: { type: "number" }
 			},
-			async handler(ctx: Context) {
+			async handler(ctx: Context<{ card: string; amount: number }>) {
 				this.logger.info("Waiting for payment finishing...", ctx.params);
 				// Simulate payment processing
 				return { status: "wait", transactionId: "12345" };
@@ -95,7 +108,7 @@ const OrdersService: ServiceSchema = {
 			params: {
 				transactionId: { type: "string", default: "12345" }
 			},
-			async handler(ctx: Context) {
+			async handler(ctx: Context<{ transactionId: string }>) {
 				this.logger.info("Payment finished for transaction", ctx.params.transactionId);
 
 				// Simulate payment completion
@@ -113,7 +126,7 @@ const OrdersService: ServiceSchema = {
 				productId: "string",
 				quantity: "number"
 			},
-			async handler(ctx: Context) {
+			async handler(ctx: Context<{ productId: string; quantity: number }>) {
 				this.logger.info("Reserving inventory for product", ctx.params.productId);
 				// Simulate inventory update
 				return {
@@ -131,7 +144,7 @@ const OrdersService: ServiceSchema = {
 			params: {
 				address: "string"
 			},
-			async handler(ctx: Context) {
+			async handler(ctx: Context<{ productId: string; address: string }>) {
 				this.logger.info("Scheduling delivery for product", ctx.params.productId);
 				// Simulate delivery scheduling
 				return {

template/services/products.service.ts

@@ -1,10 +1,9 @@
 import type { Context, Service, ServiceSchema } from "moleculer";
-import type { DbAdapter, DbServiceSettings, MoleculerDbMethods } from "@moleculer/database";
-import type { DbServiceMethods } from "../mixins/db.mixin";
-import DbMixin from "../mixins/db.mixin";
+import type { DatabaseMethods, DatabaseSettings, ApolloServiceSettings } from "../moleculer-types.js";
+import DbMixin from "../mixins/db.mixin.js";
 
 export interface ProductEntity {
-	_id: string;
+	id: string;
 	name: string;
 	price: number;
 	quantity: number;
@@ -17,15 +16,11 @@ export interface ActionQuantityParams {
 	value: number;
 }
 
-interface ProductSettings extends DbServiceSettings {
-	indexes?: Record<string, number>[];
-}
+interface ProductSettings extends DatabaseSettings, ApolloServiceSettings {}
 
-interface ProductsThis extends Service<ProductSettings>, MoleculerDbMethods {
-	adapter: DbAdapter;
-}
+interface ProductsThis extends Service<ProductSettings>, DatabaseMethods {};
 
-const ProductsService: ServiceSchema<ProductSettings> & { methods: DbServiceMethods } = {
+const ProductsService: ServiceSchema<ProductSettings> = {
 	name: "products",
 	// version: 1
 
@@ -166,16 +161,16 @@ const ProductsService: ServiceSchema<ProductSettings> & { methods: DbServiceMeth
 			{{#apiGQL}}graphql: {
 				mutation: "increaseQuantity(id: String!, value: Int!): Product"
 			},{{/apiGQL}}
-			async handler(this: ProductsThis, ctx: Context<ActionQuantityParams>): Promise<object> {
+			async handler(this: ProductsThis, ctx: Context<ActionQuantityParams>): Promise<ProductEntity> {
 				// Get current quantity
 				const adapter = await this.getAdapter(ctx);
-				const dbEntry = await adapter.findById(ctx.params.id);
+				const dbEntry = await adapter.findById<ProductEntity>(ctx.params.id);
 
 				// Compute new quantity
 				const newQuantity = dbEntry.quantity + ctx.params.value;
 
 				// Update DB entry. Will emit an event to clear the cache
-				const doc = await this.updateEntity(ctx, {
+				const doc = await this.updateEntity<ProductEntity>(ctx, {
 					id: ctx.params.id,
 					quantity: newQuantity
 				});
@@ -196,18 +191,18 @@ const ProductsService: ServiceSchema<ProductSettings> & { methods: DbServiceMeth
 			{{#apiGQL}}graphql: {
 				mutation: "decreaseQuantity(id: String!, value: Int!): Product"
 			},{{/apiGQL}}
-			async handler(this: ProductsThis, ctx: Context<ActionQuantityParams>): Promise<object> {
+			async handler(this: ProductsThis, ctx: Context<ActionQuantityParams>): Promise<ProductEntity> {
 				// Get current quantity
 				const adapter = await this.getAdapter(ctx);
-				const dbEntry = await adapter.findById(ctx.params.id);
+				const dbEntry = await adapter.findById<ProductEntity>(ctx.params.id);
 
 				// Compute new quantity
 				const newQuantity = dbEntry.quantity - ctx.params.value;
 
 				if (newQuantity < 0) throw new Error("Quantity cannot be negative");
 
 				// Update DB entry. Will emit an event to clear the cache
-				const doc = await this.updateEntity(ctx, {
+				const doc = await this.updateEntity<ProductEntity>(ctx, {
 					id: ctx.params.id,
 					quantity: newQuantity
 				});

template/tsconfig.json

@@ -99,5 +99,10 @@
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
-  }
+  },
+
+  "include": [
+    "./**/*.ts",
+    "moleculer-types.d.ts"
+  ],
 }