@bitblit/ratchet-epsilon-common 6.0.146-alpha → 6.0.148-alpha

package/src/util/epsilon-config-parser.ts

@@ -0,0 +1,90 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import yaml from 'js-yaml';
+import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { BackgroundHttpAdapterHandler } from '../background/background-http-adapter-handler.js';
+import { OpenApiDocument } from '../config/open-api/open-api-document.js';
+import { EpsilonConfig } from '../config/epsilon-config.js';
+import { EpsilonInstance } from '../epsilon-instance.js';
+import { BackgroundHandler } from '../background/background-handler.js';
+import { EpsilonRouter } from '../http/route/epsilon-router.js';
+import { RouterUtil } from '../http/route/router-util.js';
+import { WebHandler } from '../http/web-handler.js';
+import { MisconfiguredError } from '../http/error/misconfigured-error.js';
+import { EpsilonGlobalHandler } from '../epsilon-global-handler.js';
+import { BackgroundManagerLike } from '../background/manager/background-manager-like.js';
+
+export class EpsilonConfigParser {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor() {
+    // Prevent instantiation
+  }
+
+  public static epsilonConfigToEpsilonGlobalHandler(
+    config: EpsilonConfig,
+    backgroundManager?: BackgroundManagerLike,
+  ): EpsilonGlobalHandler {
+    return new EpsilonGlobalHandler(EpsilonConfigParser.epsilonConfigToEpsilonInstance(config, backgroundManager));
+  }
+
+  public static epsilonConfigToEpsilonInstance(config: EpsilonConfig, backgroundManager?: BackgroundManagerLike): EpsilonInstance {
+    this.validateGlobalConfig(config);
+    const label: string = config?.label || 'NO EPSILON CONFIG LABEL SET';
+    Logger.info('Creating epsilon : %s : BM : %j', label, backgroundManager);
+    const parsed: OpenApiDocument = EpsilonConfigParser.parseOpenApiDocument(config.openApiYamlString);
+    const modelValidator: ModelValidator = EpsilonConfigParser.openApiDocToValidator(parsed);
+    const backgroundHttpAdapter: BackgroundHttpAdapterHandler = new BackgroundHttpAdapterHandler(
+      config.backgroundConfig,
+      modelValidator,
+      backgroundManager,
+    );
+    const backgroundHandler: BackgroundHandler = config.backgroundConfig
+      ? new BackgroundHandler(config.backgroundConfig, backgroundManager, modelValidator)
+      : null;
+
+    // TODO: refactor me
+    const epsilonRouter: EpsilonRouter = config.httpConfig
+      ? RouterUtil.openApiYamlToRouterConfig(config.httpConfig, parsed, modelValidator, backgroundHttpAdapter)
+      : null;
+    const webHandler: WebHandler = epsilonRouter ? new WebHandler(epsilonRouter) : null;
+
+    const inst: EpsilonInstance = {
+      config: config,
+      parsedOpenApiDoc: parsed,
+      modelValidator: modelValidator,
+      webHandler: webHandler,
+      backgroundHandler: backgroundHandler,
+      backgroundManager: backgroundManager,
+    };
+
+    return inst;
+  }
+
+  public static parseOpenApiDocument(yamlString: string): OpenApiDocument {
+    if (!yamlString) {
+      throw new MisconfiguredError('Cannot configure, missing either yaml or cfg');
+    }
+    const doc: OpenApiDocument = yaml.load(yamlString) as OpenApiDocument;
+    return doc;
+  }
+
+  public static openApiDocToValidator(doc: OpenApiDocument): ModelValidator {
+    let rval: ModelValidator = null;
+    if (doc?.components?.schemas) {
+      rval = ModelValidator.createFromParsedObject(doc.components.schemas);
+    }
+    return rval;
+  }
+
+  public static validateGlobalConfig(config: EpsilonConfig) {
+    if (!config) {
+      ErrorRatchet.throwFormattedErr('Config may not be null');
+    }
+    if (!config.openApiYamlString) {
+      ErrorRatchet.throwFormattedErr('Config must define an open api document');
+    }
+    if (!!config.cron && !config.cron.timezone) {
+      ErrorRatchet.throwFormattedErr('Cron is defined, but timezone is not set');
+    }
+  }
+}

package/src/util/epsilon-server-util.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest';
+import { EpsilonServerMode } from '../config/espilon-server-mode.js';
+import { EpsilonServerUtil } from './epsilon-server-util.js';
+
+describe('#epsilonServerUtil', function () {
+  test('should extract server type', async () => {
+    process.env['MYTEST'] = 'Production';
+    const val: EpsilonServerMode = EpsilonServerUtil.serverMode('MYTEST', null);
+    expect(val).toEqual(EpsilonServerMode.Production);
+
+    process.env['MYTEST'] = 'asdf';
+    const val2: EpsilonServerMode = EpsilonServerUtil.serverMode('MYTEST', null);
+    expect(val2).toBeNull;
+
+    const val3: EpsilonServerMode = EpsilonServerUtil.serverMode('MYTEST', EpsilonServerMode.QA);
+    expect(val3).toEqual(EpsilonServerMode.QA);
+  });
+});

package/src/util/epsilon-server-util.ts

@@ -0,0 +1,16 @@
+import { EpsilonServerMode } from '../config/espilon-server-mode.js';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { MapRatchet } from '@bitblit/ratchet-common/lang/map-ratchet';
+
+export class EpsilonServerUtil {
+  public static serverMode(envParamName: string, def: EpsilonServerMode): EpsilonServerMode {
+    let rval: EpsilonServerMode = def;
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(envParamName);
+    if (typeof process !== 'undefined') {
+      const stVal: string = StringRatchet.trimToNull(process.env[envParamName]);
+      rval = MapRatchet.caseInsensitiveAccess<EpsilonServerMode>(EpsilonServerMode, stVal) ?? def;
+    }
+    return rval;
+  }
+}