@hiliosai/sdk 0.1.0 → 0.1.1

package/src/configs/moleculer/index.ts

@@ -0,0 +1,85 @@
+import env from '@ltv/env';
+import type {BrokerOptions} from 'moleculer';
+import os from 'os';
+
+import {bulkheadConfig} from './bulkhead';
+import {ChannelsMiddleware} from './channels';
+import {circuitBreakerConfig} from './circuit-breaker';
+import logger from './logger';
+import {metricsConfig} from './metrics';
+import {registryConfig} from './registry';
+import {retryPolicyConfig} from './retry-policy';
+import {tracingConfig} from './tracing';
+import {trackingConfig} from './tracking';
+
+const pkgNm = env.string('NAMESPACE', 'hios');
+
+const nodeID =
+  env.string('NODE_ID') ?? `${pkgNm}-${os.hostname()}-${process.pid}`;
+
+// Export default config for backward compatibility
+const configs: BrokerOptions = {
+  namespace: pkgNm,
+  nodeID,
+  metadata: {},
+  logger,
+  // Default log level for built-in console logger. It can be overwritten in logger options above.
+  // Available values: trace, debug, info, warn, error, fatal
+  logLevel: 'info',
+
+  cacher: env.string('REDIS_URL', 'Memory'),
+
+  // Define a serializer.
+  // Available values: "JSON", "Avro", "ProtoBuf", "MsgPack", "Notepack", "Thrift".
+  // More info: https://moleculer.services/docs/0.14/networking.html#Serialization
+  serializer: 'JSON',
+
+  // Number of milliseconds to wait before reject a request with a RequestTimeout error. Disabled: 0
+  requestTimeout: 10 * 1000,
+
+  // Retry policy settings. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Retry
+  retryPolicy: retryPolicyConfig,
+
+  // Limit of calling level. If it reaches the limit, broker will throw an MaxCallLevelError error. (Infinite loop protection)
+  maxCallLevel: 100,
+
+  // Number of seconds to send heartbeat packet to other nodes.
+  heartbeatInterval: 10,
+  // Number of seconds to wait before setting node to unavailable status.
+  heartbeatTimeout: 30,
+
+  // Cloning the params of context if enabled. High performance impact, use it with caution!
+  contextParamsCloning: false,
+
+  // Tracking requests and waiting for running requests before shuting down. More info: https://moleculer.services/docs/0.14/context.html#Context-tracking
+  tracking: trackingConfig,
+
+  // Disable built-in request & emit balancer. (Transporter must support it, as well.). More info: https://moleculer.services/docs/0.14/networking.html#Disabled-balancer
+  disableBalancer: false,
+
+  // Settings of Service Registry. More info: https://moleculer.services/docs/0.14/registry.html
+  registry: registryConfig,
+
+  // Settings of Circuit Breaker. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Circuit-Breaker
+  circuitBreaker: circuitBreakerConfig,
+
+  // Settings of bulkhead feature. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Bulkhead
+  bulkhead: bulkheadConfig,
+
+  // Enable action & event parameter validation. More info: https://moleculer.services/docs/0.14/validating.html
+  validator: 'Fastest',
+
+  // errorHandler: null,
+
+  transporter: env.string('TRANSPORTER_URL'),
+
+  // Enable/disable built-in metrics function. More info: https://moleculer.services/docs/0.14/metrics.html
+  metrics: metricsConfig,
+
+  // Enable built-in tracing function. More info: https://moleculer.services/docs/0.14/tracing.html
+  tracing: tracingConfig,
+
+  middlewares: [ChannelsMiddleware],
+};
+
+export default configs;

package/src/configs/moleculer/logger.ts

@@ -0,0 +1,17 @@
+const loggerConfig = {
+  type: 'Console',
+  options: {
+    // Using colors on the output
+    colors: true,
+    // Print module names with different colors (like docker-compose for containers)
+    moduleColors: false,
+    // Line formatter. It can be "json", "short", "simple", "full", a `Function` or a template string like "{timestamp} {level} {nodeID}/{mod}: {msg}"
+    formatter: 'full',
+    // Custom object printer. If not defined, it uses the `util.inspect` method.
+    objectPrinter: null,
+    // Auto-padding the module name in order to messages begin at the same column.
+    autoPadding: false,
+  },
+};
+
+export default loggerConfig;

package/src/configs/moleculer/metrics.ts

@@ -0,0 +1,20 @@
+import type {MetricRegistry} from 'moleculer';
+
+export const metricsConfig = {
+  enabled: false,
+  // Available built-in reporters: "Console", "CSV", "Event", "Prometheus", "Datadog", "StatsD"
+  reporter: {
+    type: 'Prometheus',
+    options: {
+      // HTTP port
+      port: 3030,
+      // HTTP URL path
+      path: '/metrics',
+      // Default labels which are appended to all metrics labels
+      defaultLabels: (registry: MetricRegistry) => ({
+        namespace: registry.broker.namespace,
+        nodeID: registry.broker.nodeID,
+      }),
+    },
+  },
+};

package/src/configs/moleculer/registry.ts

@@ -0,0 +1,7 @@
+export const registryConfig = {
+  // Define balancing strategy. More info: https://moleculer.services/docs/0.14/balancing.html
+  // Available values: "RoundRobin", "Random", "CpuUsage", "Latency", "Shard"
+  strategy: 'RoundRobin',
+  // Enable local action call preferring. Always call the local action instance if available.
+  preferLocal: true,
+};

package/src/configs/moleculer/retry-policy.ts

@@ -0,0 +1,17 @@
+import type {Errors} from 'moleculer';
+
+export const retryPolicyConfig = {
+  // Enable feature
+  enabled: false,
+  // Count of retries
+  retries: 5,
+  // First delay in milliseconds.
+  delay: 100,
+  // Maximum delay in milliseconds.
+  maxDelay: 1000,
+  // Backoff factor for delay. 2 means exponential backoff.
+  factor: 2,
+  // A function to check failed requests.
+  check: (err: Errors.MoleculerError | Error) =>
+    !!(err as Errors.MoleculerError).retryable,
+};

package/src/configs/moleculer/tracing.ts

@@ -0,0 +1,6 @@
+export const tracingConfig = {
+  enabled: true,
+  exporter: 'Console',
+  events: true,
+  stackTrace: true,
+};

package/src/configs/moleculer/tracking.ts

@@ -0,0 +1,6 @@
+export const trackingConfig = {
+  // Enable feature
+  enabled: false,
+  // Number of milliseconds to wait before shuting down the process.
+  shutdownTimeout: 5000,
+};

package/src/datasources/base.datasource.ts

@@ -0,0 +1,79 @@
+/**
+ * Base datasource interface that all datasources should implement
+ * Provides common structure and optional lifecycle methods
+ */
+export interface BaseDatasource {
+  /**
+   * Datasource name for identification and logging
+   */
+  readonly name: string;
+
+  /**
+   * Optional initialization method
+   * Called when datasource is instantiated
+   */
+  init?(): Promise<void> | void;
+
+  /**
+   * Optional connection method
+   * Called when service starts if implemented
+   */
+  connect?(): Promise<void> | void;
+
+  /**
+   * Optional disconnection method
+   * Called when service stops if implemented
+   */
+  disconnect?(): Promise<void> | void;
+
+  /**
+   * Optional health check method
+   * Can be used to verify datasource is working correctly
+   */
+  healthCheck?(): Promise<boolean> | boolean;
+
+  /**
+   * Optional method to clear/reset the datasource
+   */
+  clear?(): Promise<void> | void;
+}
+
+/**
+ * Abstract base class for datasources that provides default implementations
+ * @example
+ * ```typescript
+ * export class UserDatasource extends AbstractDatasource {
+ *   readonly name = 'users';
+ *
+ *   private users: User[] = [];
+ *
+ *   async findById(id: string): Promise<User | undefined> {
+ *     return this.users.find(u => u.id === id);
+ *   }
+ *
+ *   async create(user: User): Promise<User> {
+ *     this.users.push(user);
+ *     return user;
+ *   }
+ * }
+ * ```
+ */
+export abstract class AbstractDatasource implements BaseDatasource {
+  abstract readonly name: string;
+
+  /**
+   * Default health check - always returns true
+   * Override for custom health check logic
+   */
+  async healthCheck(): Promise<boolean> {
+    return true;
+  }
+
+  /**
+   * Default clear method - does nothing
+   * Override to implement clearing logic
+   */
+  async clear(): Promise<void> {
+    // Default implementation - does nothing
+  }
+}

package/src/datasources/index.ts

@@ -0,0 +1 @@
+export * from './base.datasource';

package/src/middlewares/context-helpers.middleware.ts

@@ -110,7 +110,10 @@ export const ContextHelpersMiddleware = {
         ctx.broker.logger.info('Audit log', {
           action,
           resource: resource
-            ? {type: typeof resource, id: (resource as Record<string, unknown>).id}
+            ? {
+                type: typeof resource,
+                id: (resource as Record<string, unknown>).id,
+              }
             : undefined,
           userId: ctx.meta.user?.id,
           tenantId: ctx.meta.tenantId,

package/src/middlewares/datasource.middleware.ts

@@ -1,10 +1,12 @@
 import type {Context} from 'moleculer';
+import type {BaseDatasource} from '../datasources';
 
 /**
  * Datasource constructor registry type
+ * All datasources should implement BaseDatasource interface
  */
 export interface DatasourceConstructorRegistry {
-  [key: string]: new () => object;
+  [key: string]: new () => BaseDatasource | object;
 }
 
 /**

package/src/middlewares/index.ts

@@ -3,4 +3,3 @@ export * from './memoize.middleware';
 export * from './health.middleware';
 export * from './permissions.middleware';
 export * from './context-helpers.middleware';
-export * from './cache.middleware';

package/src/mixins/datasource.mixin.ts

@@ -0,0 +1,118 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type {ServiceSchema} from 'moleculer';
+import type {BaseDatasource} from '../datasources';
+import type {AppContext} from '../types/context';
+
+/**
+ * Datasource constructor registry type
+ * All datasources should implement BaseDatasource interface
+ */
+export interface DatasourceConstructorRegistry {
+  [key: string]: new () => BaseDatasource | object;
+}
+
+/**
+ * Datasource instance registry type
+ */
+export interface DatasourceInstanceRegistry {
+  [key: string]: object;
+}
+
+/**
+ * Creates a Moleculer mixin for datasource injection
+ * Simple mixin that just instantiates datasources and injects them into context
+ *
+ * @example
+ * ```typescript
+ * import {DatasourceMixin} from '@pkg/sdk';
+ *
+ * export default {
+ *   name: 'users',
+ *   mixins: [DatasourceMixin({
+ *     userDb: UserDatasource,
+ *     cache: CacheDatasource,
+ *   })],
+ *   actions: {
+ *     get: {
+ *       handler(ctx) {
+ *         // Access datasources via ctx.datasources
+ *         return ctx.datasources.userDb.findById(ctx.params.id);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function DatasourceMixin(
+  datasourceConstructors: DatasourceConstructorRegistry = {}
+): Partial<ServiceSchema> {
+  // Initialize datasources once
+  const datasourceInstances: DatasourceInstanceRegistry = {};
+
+  for (const [key, DatasourceClass] of Object.entries(datasourceConstructors)) {
+    datasourceInstances[key] = new DatasourceClass();
+  }
+
+  return {
+    /**
+     * Service created lifecycle hook
+     * Initialize datasources and store on service
+     */
+    async created() {
+      // Call init() on datasources that have it
+      for (const [, datasource] of Object.entries(datasourceInstances)) {
+        if (typeof (datasource as any).init === 'function') {
+          await (datasource as any).init();
+        }
+      }
+
+      // Store instances on the service for access in methods
+      (this as any).$datasources = datasourceInstances;
+    },
+
+    /**
+     * Service started lifecycle hook
+     * Connect datasources that have connect method
+     */
+    async started() {
+      // Call connect() on datasources that have it
+      for (const [, datasource] of Object.entries(datasourceInstances)) {
+        if (typeof (datasource as any).connect === 'function') {
+          await (datasource as any).connect();
+        }
+      }
+    },
+
+    /**
+     * Service stopped lifecycle hook
+     * Disconnect datasources that have disconnect method
+     */
+    async stopped() {
+      // Call disconnect() on datasources that have it
+      for (const [, datasource] of Object.entries(datasourceInstances)) {
+        if (typeof (datasource as any).disconnect === 'function') {
+          await (datasource as any).disconnect();
+        }
+      }
+    },
+
+    /**
+     * Hooks to inject datasources into context
+     */
+    hooks: {
+      before: {
+        '*': function injectDatasources(ctx) {
+          // Inject datasources into the context
+          (ctx as AppContext).datasources = (this as any).$datasources ?? {};
+        },
+      },
+    },
+  };
+}
+
+/**
+ * Type helper for services that use the datasource mixin
+ */
+export type ServiceWithDatasources<T extends DatasourceInstanceRegistry> = {
+  datasources: T;
+};

package/src/mixins/index.ts

@@ -0,0 +1 @@
+export * from './datasource.mixin';