@bitblit/ratchet-misc 6.0.145-alpha → 6.0.147-alpha

package/src/handlebars/handlebars-ratchet.ts

@@ -0,0 +1,151 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
+
+export class HandlebarsRatchet {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  // Disabling ban-types here because I really DO want to accept and function-like object here
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  public static functionMap(): Record<string, Function> {
+    return {
+      eq: HandlebarsRatchet.equal,
+      ne: HandlebarsRatchet.notEqual,
+      lt: HandlebarsRatchet.lessThan,
+      gt: HandlebarsRatchet.greaterThan,
+      lte: HandlebarsRatchet.lessThanEqual,
+      gte: HandlebarsRatchet.greaterThanEqual,
+      and: HandlebarsRatchet.and,
+      or: HandlebarsRatchet.or,
+      formatBytes: HandlebarsRatchet.formatBytes,
+      rpn: HandlebarsRatchet.reversePolishNotation,
+
+      add: HandlebarsRatchet.add,
+      sub: HandlebarsRatchet.sub,
+      mul: HandlebarsRatchet.mul,
+      div: HandlebarsRatchet.div,
+      mod: HandlebarsRatchet.mod,
+      maxNum: HandlebarsRatchet.maxNum,
+      minNum: HandlebarsRatchet.minNum,
+    };
+  }
+
+  public static registerAll(handlebars: any): void {
+    handlebars.registerHelper(HandlebarsRatchet.functionMap());
+  }
+
+  public static add(v1: number, v2: number): number {
+    return NumberRatchet.safeNumber(v1) + NumberRatchet.safeNumber(v2);
+  }
+
+  public static sub(v1: number, v2: number): number {
+    return NumberRatchet.safeNumber(v1) - NumberRatchet.safeNumber(v2);
+  }
+
+  public static mul(v1: number, v2: number): number {
+    return NumberRatchet.safeNumber(v1) * NumberRatchet.safeNumber(v2);
+  }
+
+  public static div(v1: number, v2: number): number {
+    return NumberRatchet.safeNumber(v1) / NumberRatchet.safeNumber(v2);
+  }
+
+  public static mod(v1: number, v2: number): number {
+    return NumberRatchet.safeNumber(v1) % NumberRatchet.safeNumber(v2);
+  }
+
+  public static equal(v1: any, v2: any): boolean {
+    return v1 === v2;
+  }
+
+  public static notEqual(v1: any, v2: any): boolean {
+    return v1 !== v2;
+  }
+
+  public static lessThan(v1: any, v2: any): boolean {
+    return v1 < v2;
+  }
+
+  public static lessThanEqual(v1: any, v2: any): boolean {
+    return v1 <= v2;
+  }
+
+  public static greaterThan(v1: any, v2: any): boolean {
+    return v1 > v2;
+  }
+
+  public static greaterThanEqual(v1: any, v2: any): boolean {
+    return v1 >= v2;
+  }
+
+  public static maxNum(...args: number[]): number {
+    return Math.max(...args.slice(0, -1));
+  }
+
+  public static minNum(...args: number[]): number {
+    return Math.min(...args.slice(0, -1));
+  }
+
+  public static and(...args: any[]): boolean {
+    return Array.prototype.every.call(args, Boolean);
+  }
+
+  public static or(...args: any[]): boolean {
+    return Array.prototype.slice.call(args, 0, -1).some(Boolean);
+  }
+
+  public static formatBytes(v1: number): string {
+    return StringRatchet.formatBytes(v1);
+  }
+
+  /**
+   * Soo... why have a implementation of reverse polish notation for Handlebars?  Well basically
+   * because handlebars does not support doing math internally, and sometimes I want to be able
+   * to do arbitrarily complex math inside my template, and even if I have functions like
+   * add and div, I cannot do things like this in templates (usually):
+   * add 5 (div 10 8)
+   * because handlebars typically will not do the parens correctly.  So, when you use RPN, there
+   * are no parenthesis, operation order is handled by the stack, so you can put pretty much anything
+   * you want in here
+   *
+   * And spare me any lectures about the evils of ANY logic in templates... if you send them my way, I'll assume you
+   * are someone who has spent your whole life working in a university system and never having to make a payroll
+   * @param args
+   */
+  public static reversePolishNotation(...args: any[]): string {
+    let rval: string = null;
+
+    try {
+      // Disabling ban-types here because I really DO want to accept and function-like object here
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      const fns: Record<string, Function> = Object.assign({}, HandlebarsRatchet.functionMap());
+      delete fns['formatBytes']; // Not a 2-function op
+
+      const stack = [];
+      // Skip the last value since it is a ref back to the function itself
+      for (let i = 0; i < args.length - 1; i++) {
+        const a = args[i];
+        if (fns[a]) {
+          if (stack.length > 1) {
+            const op2: any = stack.pop();
+            const op1: any = stack.pop();
+            const res: any = fns[a](op1, op2, {}); // Add back in the last-place placeholder for any ...any f
+            stack.push(res);
+          } else {
+            ErrorRatchet.throwFormattedErr('Cannot execute operation %s - not enough args', a);
+          }
+        } else {
+          stack.push(a);
+        }
+      }
+      rval = stack.pop();
+    } catch (err) {
+      Logger.error('Failed to execute RPN: %s', err, err);
+      rval = ErrorRatchet.asErr(err)?.message || 'Failure';
+    }
+    return rval;
+  }
+}

package/src/handlebars/remote-handlebars-template-renderer.ts

@@ -0,0 +1,87 @@
+import handlebars from 'handlebars';
+import fetch from 'cross-fetch';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import layouts from 'handlebars-layouts';
+import { RatchetTemplateRenderer } from '@bitblit/ratchet-common/template/ratchet-template-renderer';
+import Template = Handlebars.Template;
+
+/**
+ */
+
+export class RemoteHandlebarsTemplateRenderer implements RatchetTemplateRenderer {
+  private cache: Map<string, HandlebarsTemplateDelegate>;
+
+  constructor(
+    private prefix: string = '',
+    private suffix: string = '',
+    private maxCacheTemplates: number = 10,
+  ) {
+    if (this.maxCacheTemplates > 0) {
+      this.cache = new Map<string, HandlebarsTemplateDelegate>();
+    }
+  }
+
+  public async renderTemplate(templateName: string, context: any, layoutName: string = null): Promise<string> {
+    return this.renderRemoteTemplate(templateName, context, layoutName);
+  }
+
+  public async renderRemoteTemplate(templateName: string, inContext: any, layoutName: string = null): Promise<string> {
+    const template: HandlebarsTemplateDelegate = await this.fetchTemplate(templateName);
+    const layoutText: string = layoutName ? await this.fetchTemplateText(layoutName) : null;
+
+    if (layoutText) {
+      await layouts.register(handlebars);
+      handlebars.registerPartial(layoutName, layoutText);
+    }
+
+    const context: any = inContext || {};
+    const result: string = template ? template(context) : null;
+    return result;
+  }
+
+  public async renderTemplateDirect(templateText: string, context: any, layoutName: string = null): Promise<string> {
+    const template: Template = handlebars.compile(templateText);
+    const result: string = template(context);
+    return result;
+  }
+
+  private async fetchTemplate(templateName: string): Promise<HandlebarsTemplateDelegate> {
+    let rval: HandlebarsTemplateDelegate = null;
+    try {
+      if (!!this.cache && this.cache.has(templateName)) {
+        Logger.silly('Cache hit for template : %s', templateName);
+        rval = this.cache.get(templateName);
+      } else {
+        Logger.debug('Cache miss for template : %s', templateName);
+        const templateText: string = await this.fetchTemplateText(templateName);
+        if (templateText) {
+          rval = handlebars.compile(templateText);
+          if (!!this.cache && !!rval) {
+            this.cache.set(templateName, rval);
+            if (this.cache.size > this.maxCacheTemplates) {
+              this.cache.delete(Array.from(this.cache.keys())[0]);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      Logger.warn('Could not fetch and compile template : %s : %s', templateName, err, err);
+      rval = null;
+    }
+    return rval;
+  }
+
+  private async fetchTemplateText(templateName: string): Promise<string> {
+    let rval: string = null;
+    const url: string = StringRatchet.trimToEmpty(this.prefix) + templateName + StringRatchet.trimToEmpty(this.suffix);
+    try {
+      const resp: Response = await fetch(url);
+      rval = await resp.text();
+    } catch (err) {
+      Logger.warn('Could not fetch url : %s : %s', url, err, err);
+      rval = null;
+    }
+    return rval;
+  }
+}

package/src/model-validator/model-validator.spec.ts

@@ -0,0 +1,43 @@
+import { ModelValidator } from './model-validator.js';
+import fs from 'fs';
+import path from 'path';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { EsmRatchet } from '@bitblit/ratchet-common/lang/esm-ratchet';
+import { describe, expect, test } from 'vitest';
+
+describe('#modelValidator', function () {
+  test('should list an error', function () {
+    const yamlString: string = fs
+      .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/sample-objects.spec.yaml'))
+      .toString();
+    const validator: ModelValidator = ModelValidator.createFromYamlString(yamlString, ['ModelObjects']);
+
+    const shouldPass: any = {
+      numberField: 7,
+      stringField: 'xxx',
+    };
+
+    const shouldFail: any = {
+      numberField: 70,
+      stringField: 'xxx',
+    };
+
+    const errShouldPass: string[] = validator.validate('SimpleItem', shouldPass, false, true);
+    const errShouldFail: string[] = validator.validate('SimpleItem', shouldFail, false, true);
+
+    Logger.silly('shouldPass: %j', errShouldPass);
+    Logger.silly('shouldFail: %j', errShouldFail);
+
+    expect(errShouldPass).toBeTruthy();
+    expect(errShouldPass.length).toEqual(0);
+
+    expect(errShouldFail).toBeTruthy();
+    expect(errShouldFail.length).toEqual(1);
+
+    const modelNames: string[] = validator.modelNames;
+    expect(modelNames.length).toEqual(2);
+    expect(modelNames.includes('SimpleItem')).toBeTruthy();
+    expect(modelNames.includes('ApiErrorResponse')).toBeTruthy();
+    expect(modelNames.includes('XYZ')).toBeFalsy();
+  });
+});

package/src/model-validator/model-validator.ts

@@ -0,0 +1,67 @@
+import Validator from 'swagger-model-validator';
+import yaml from 'js-yaml';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { MapRatchet } from '@bitblit/ratchet-common/lang/map-ratchet';
+
+/**
+ * Helper for validating endpoints
+ */
+export class ModelValidator {
+  constructor(private allModels: any) {
+    if (!allModels || Object.keys(allModels).length == 0) {
+      ErrorRatchet.throwFormattedErr('Cannot create model validator, passed models was null/empty : %j', allModels);
+    }
+  }
+
+  public static createFromYamlString(yamlString: string, rootPath: string[]): ModelValidator {
+    const src: any = yaml.load(yamlString);
+    const modelSrc: any = rootPath && rootPath.length > 0 ? MapRatchet.findValue(src, rootPath) : src;
+    return ModelValidator.createFromParsedObject(modelSrc);
+  }
+
+  public static createFromParsedObject(parsedObject: any): ModelValidator {
+    return new ModelValidator(parsedObject);
+  }
+
+  public get modelNames(): string[] {
+    return Object.keys(this.allModels);
+  }
+
+  public addModel(modelName: string, model: any): void {
+    this.allModels[modelName] = model;
+  }
+
+  public fetchModel(modelName: string): any {
+    return this.allModels[modelName];
+  }
+
+  public validate(modelName: string, modelObject: any, emptyAllowed: boolean = false, extraPropertiesAllowed: boolean = true): string[] {
+    let rval: string[] = [];
+    Logger.silly('Validating model %s all definitions are : %j', modelName, this.allModels);
+
+    const modelEmpty: boolean = !modelObject || Object.keys(modelObject).length === 0;
+    if (modelEmpty) {
+      if (!emptyAllowed) {
+        rval.push('Empty / null object sent, but empty not allowed here');
+      }
+    } else {
+      if (this.allModels && modelName && this.allModels[modelName]) {
+        const validation = new Validator().validate(
+          modelObject,
+          this.allModels[modelName],
+          this.allModels,
+          emptyAllowed,
+          extraPropertiesAllowed,
+        );
+
+        if (validation.errorCount > 0) {
+          rval = validation.errors.map((e) => e.message);
+        }
+      } else {
+        rval = ['Model named "' + modelName + '" not present in schema'];
+      }
+    }
+    return rval;
+  }
+}

package/src/rxjs/observable-ratchet.spec.ts

@@ -0,0 +1,21 @@
+import { timer } from 'rxjs';
+import { ObservableRatchet } from './observable-ratchet.js';
+import { TimeoutToken } from '@bitblit/ratchet-common/lang/timeout-token';
+import { describe, expect, test } from 'vitest';
+
+describe('#timeout', function () {
+  test('should correctly return before timeout', function () {
+    const src = timer(1000);
+    const timeoutOb = ObservableRatchet.timeout(src, '1000ms interval', 1500);
+    timeoutOb.subscribe((result) => expect(result).toEqual(0));
+  });
+
+  test('should correctly returns null after timeout', function () {
+    const src = timer(1500);
+    const timeoutOb = ObservableRatchet.timeout(src, '1500ms interval', 1000);
+    timeoutOb.subscribe((result) => {
+      expect(result).toBeTruthy();
+      expect(result instanceof TimeoutToken).toBeTruthy();
+    });
+  });
+});

package/src/rxjs/observable-ratchet.ts

@@ -0,0 +1,27 @@
+import { Observable, Observer, race } from 'rxjs';
+import { TimeoutToken } from '@bitblit/ratchet-common/lang/timeout-token';
+
+/**
+ * A class for simplifying working with rxjs observables.
+ *
+ * Contributed by William Weiss <npm@codification.org>
+ */
+export class ObservableRatchet {
+  public static timeout<T>(
+    srcObservable: Observable<T | TimeoutToken>,
+    title: string,
+    timeoutMillis: number,
+  ): Observable<T | TimeoutToken> {
+    const rval: Observable<unknown> = race(srcObservable, this.createTimeoutObservable(title, timeoutMillis));
+    return rval as Observable<T | TimeoutToken>;
+  }
+
+  public static createTimeoutObservable<T>(title: string, timeoutMillis: number): Observable<T | TimeoutToken> {
+    return Observable.create((observer: Observer<T | TimeoutToken>) => {
+      const id = setTimeout(() => {
+        clearTimeout(id);
+        observer.next(new TimeoutToken(title, timeoutMillis));
+      }, timeoutMillis);
+    });
+  }
+}

package/src/rxjs/rxjs-ratchet.spec.ts

@@ -0,0 +1,22 @@
+import { BehaviorSubject } from 'rxjs';
+import { RxjsRatchet } from './rxjs-ratchet.js';
+import { PromiseRatchet } from '@bitblit/ratchet-common/lang/promise-ratchet';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { describe, expect, test } from 'vitest';
+
+describe('#waitForNonNullOnSubject', function () {
+  test('should resolve after 1 second', async () => {
+    const sub: BehaviorSubject<number> = new BehaviorSubject<number>(null);
+    //const testFn: any =
+    PromiseRatchet.wait(1000).then((r) => {
+      sub.next(5);
+    });
+
+    Logger.info('Waiting for non-null');
+
+    const result: number = await RxjsRatchet.waitForNonNullOnSubject(sub);
+    Logger.info('Got %d', result);
+
+    expect(result).toEqual(5);
+  }, 10000);
+});

package/src/rxjs/rxjs-ratchet.ts

@@ -0,0 +1,44 @@
+/*
+    Functions for working with rxjs objects
+*/
+
+import { MapRatchet } from '@bitblit/ratchet-common/lang/map-ratchet';
+import { BehaviorSubject, Subscription } from 'rxjs';
+
+export class RxjsRatchet {
+  public static safeUnsubscribe(sub: any): boolean {
+    return MapRatchet.safeCallFunction(sub, 'unsubscribe');
+  }
+
+  public static async waitForNonNullOnSubject<T>(subject: BehaviorSubject<T>): Promise<T> {
+    if (subject.value) {
+      return subject.value;
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      return new Promise<T>((resolve, reject) => {
+        const innerSub: Subscription = subject.subscribe((val) => {
+          if (val) {
+            RxjsRatchet.safeUnsubscribe(innerSub);
+            resolve(val);
+          }
+        });
+      });
+    }
+  }
+
+  public static async waitForTargetValueOnSubject<T>(subject: BehaviorSubject<T>, targetValue: T): Promise<T> {
+    if (subject.value === targetValue) {
+      return subject.value;
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      return new Promise<T>((resolve, reject) => {
+        const innerSub: Subscription = subject.subscribe((val) => {
+          if (val === targetValue) {
+            RxjsRatchet.safeUnsubscribe(innerSub);
+            resolve(val);
+          }
+        });
+      });
+    }
+  }
+}

package/src/sobol/generated/.openapi-generator/FILES

@@ -0,0 +1,53 @@
+.openapi-generator-ignore
+apis/AgreementsApi.ts
+apis/CustomFieldValuesApi.ts
+apis/CustomFieldsApi.ts
+apis/GoalsApi.ts
+apis/RoleAssignmentsApi.ts
+apis/RolesApi.ts
+apis/TeamsApi.ts
+apis/UsersApi.ts
+apis/index.ts
+index.ts
+models/Address.ts
+models/AddressTypeInternalEnum.ts
+models/Agreement.ts
+models/AgreementOwnersInner.ts
+models/AgreementSignatoriesInner.ts
+models/CustomField.ts
+models/CustomFieldBadgeConfig.ts
+models/CustomFieldBadgeConfigOptionsValue.ts
+models/CustomFieldBadgeContent.ts
+models/CustomFieldBadgeContentBadgesInner.ts
+models/CustomFieldConfig.ts
+models/CustomFieldMultiSelectDropDownConfig.ts
+models/CustomFieldMultiSelectDropDownContent.ts
+models/CustomFieldMultiSelectDropDownContentSelectedOptions.ts
+models/CustomFieldSingleSelectDropDownConfig.ts
+models/CustomFieldSingleSelectDropDownConfigOptionsValue.ts
+models/CustomFieldSingleSelectDropDownContent.ts
+models/CustomFieldSingleSelectDropDownContentSelectedOptions.ts
+models/CustomFieldTextConfig.ts
+models/CustomFieldTextContent.ts
+models/CustomFieldValue.ts
+models/CustomFieldValueContent.ts
+models/FeatureToggle.ts
+models/GlobalIdentity.ts
+models/GlobalUserSettings.ts
+models/Goal.ts
+models/GoalOwnersInner.ts
+models/GoalParentGoal.ts
+models/GoalValue.ts
+models/LocalIdentity.ts
+models/ObjectRef.ts
+models/Role.ts
+models/RoleAccountableTo.ts
+models/RoleAssignment.ts
+models/RoleAssignmentsInner.ts
+models/RoleContributesTo.ts
+models/Team.ts
+models/TeamOwnersInner.ts
+models/User.ts
+models/UserLocalIdentitiesInner.ts
+models/index.ts
+runtime.ts

package/src/sobol/generated/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.3.0

package/src/sobol/generated/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md