@goast/core 0.4.0-beta4 → 0.4.0

package/src/src/utils/action-provider.ts

@@ -0,0 +1,58 @@
+// deno-lint-ignore-file
+import type { EmptyConstructor, FunctionNames } from './type.utils.js';
+
+type MatchingFunctionNames<T, TAction> = {
+  [K in keyof T]: T[K] extends TAction ? K : never;
+}[keyof T];
+
+type CtorActionRunner<T, TAction> = {
+  kind: 'ctor';
+  factory: EmptyConstructor<T>;
+  functionName: MatchingFunctionNames<T, TAction>;
+};
+
+type FnActionRunner<TAction> = {
+  kind: 'fn';
+  action: TAction;
+};
+
+type ValueActionRunner<T, TAction> = {
+  kind: 'value';
+  value: T;
+  functionName: MatchingFunctionNames<T, TAction>;
+};
+
+type ActionRunner<TAction> = CtorActionRunner<any, TAction> | FnActionRunner<TAction> | ValueActionRunner<any, TAction>;
+
+export class ActionProvider<TAction extends (...args: any[]) => any> {
+  constructor(private readonly _runner: ActionRunner<TAction>) {}
+
+  public run(...args: Parameters<TAction>): ReturnType<TAction> {
+    switch (this._runner.kind) {
+      case 'ctor':
+        return new this._runner.factory()[this._runner.functionName as any](...args);
+      case 'fn':
+        return this._runner.action(...args);
+      case 'value':
+        return this._runner.value[this._runner.functionName as any](...args);
+    }
+  }
+
+  public static fromType<T, TName extends FunctionNames<T>>(
+    type: EmptyConstructor<T>,
+    functionName: TName,
+  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
+    return new ActionProvider({ kind: 'ctor', factory: type, functionName: functionName as any });
+  }
+
+  public static fromFn<TAction extends (...args: any[]) => any>(fn: TAction): ActionProvider<TAction> {
+    return new ActionProvider({ kind: 'fn', action: fn });
+  }
+
+  public static fromValue<T, TName extends FunctionNames<T>>(
+    value: T,
+    functionName: TName,
+  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
+    return new ActionProvider({ kind: 'value', value, functionName: functionName as any });
+  }
+}

package/src/src/utils/array.utils.ts

@@ -0,0 +1,7 @@
+export function removeItems<T>(array: T[], predicate: (item: T) => boolean): void {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i])) {
+      array.splice(i, 1);
+    }
+  }
+}

package/src/src/utils/asset-manager.ts

@@ -0,0 +1,51 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { basename, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+
+import fs from 'fs-extra';
+
+export class AssetManager {
+  private readonly _assetsBaseUrl: URL;
+
+  constructor(assetsBaseUrl: URL) {
+    this._assetsBaseUrl = assetsBaseUrl;
+  }
+
+  public async getAssetFileContent(relativePath: string): Promise<string> {
+    if (this._assetsBaseUrl.protocol === 'file:') {
+      return await fs.readFile(resolve(fileURLToPath(this._assetsBaseUrl), relativePath), 'utf8');
+    } else {
+      return await this.fetchAssetFile(relativePath);
+    }
+  }
+
+  public async copyAssetFile(relativePath: string, destDir: string, logName?: string): Promise<void> {
+    const targetPath = resolve(destDir, basename(relativePath));
+    if (logName !== undefined) {
+      if (logName) {
+        console.log(`Copying ${logName} to "${targetPath}"`);
+      } else {
+        console.log(`Copying asset file "${relativePath}" to "${targetPath}"`);
+      }
+    }
+    if (this._assetsBaseUrl.protocol === 'file:') {
+      const srcPath = resolve(fileURLToPath(this._assetsBaseUrl), relativePath);
+      await fs.copyFile(srcPath, targetPath);
+    } else {
+      const fileContent = await this.fetchAssetFile(relativePath);
+      await fs.outputFile(targetPath, fileContent);
+    }
+  }
+
+  private async fetchAssetFile(relativePath: string): Promise<string> {
+    const url = new URL(relativePath, this._assetsBaseUrl);
+    const response = await dntShim.fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch asset file "${relativePath}" from "${url.href}": ${response.statusText} (${response.status})`,
+      );
+    }
+    return await response.text();
+  }
+}

package/src/src/utils/class.utils.ts

@@ -0,0 +1,40 @@
+// deno-lint-ignore-file no-explicit-any
+export function classifyArray<TItem, TClassification extends Record<string, abstract new (...args: any[]) => any>>(
+  items: Iterable<TItem>,
+  classification: TClassification,
+): { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
+  rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
+} {
+  const result = { rest: [] } as { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
+    rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
+  };
+
+  for (const key in classification) {
+    (result as any)[key] = [];
+  }
+
+  for (const item of items) {
+    let classified = false;
+    for (const key in classification) {
+      const type = classification[key];
+      if (item instanceof type) {
+        result[key].push(item as any);
+        classified = true;
+        break;
+      }
+    }
+    if (!classified) {
+      result.rest.push(item as any);
+    }
+  }
+
+  return result;
+}
+
+export function isInstanceOf<T>(item: unknown, type: abstract new (...args: any[]) => T): item is T {
+  return item instanceof type;
+}
+
+export function getIsInstanceOf<T>(type: abstract new (...args: any[]) => T): (item: unknown) => item is T {
+  return (item): item is T => item instanceof type;
+}

package/src/src/utils/common.utils.test.ts

@@ -0,0 +1,22 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, test } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { isNullish } from './common.utils.js';
+
+describe('isNullish', () => {
+  test('returns true for null', () => {
+    expect(isNullish(null)).toBe(true);
+  });
+
+  test('returns true for undefined', () => {
+    expect(isNullish(undefined)).toBe(true);
+  });
+
+  test('returns false for any other value', () => {
+    expect(isNullish('')).toBe(false);
+    expect(isNullish(false)).toBe(false);
+    expect(isNullish(0)).toBe(false);
+    expect(isNullish({})).toBe(false);
+  });
+});

package/src/src/utils/common.utils.ts

@@ -0,0 +1,86 @@
+import type { SingleOrMultiple } from './type.utils.js';
+
+export function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+export function notNullish<T>(value: T): value is NonNullable<T> {
+  return !isNullish(value);
+}
+
+export function concatSingleOrMultiple<T>(...values: SingleOrMultiple<T>[]): SingleOrMultiple<T> {
+  if (values.length === 1) {
+    return values[0];
+  }
+  const result: T[] = [];
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      result.push(...value);
+    } else {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+export function isIterable(value: unknown): value is Iterable<unknown> {
+  return typeof value === 'object' && value !== null && Symbol.iterator in value;
+}
+
+export function toArray<T>(value: T | T[] | Iterable<T>): T[] {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (isIterable(value)) {
+    return Array.from(value);
+  }
+  return [value];
+}
+
+export function modify<T>(value: T, callback: (value: NonNullable<T>) => void): T {
+  if (notNullish(value)) {
+    callback(value);
+  }
+  return value;
+}
+
+export function run<T>(value: T, callback: (value: T) => void): T {
+  callback(value);
+  return value;
+}
+
+export function transform<T, U>(value: T, callback: (value: T) => U): U {
+  return callback(value);
+}
+
+type IterableItem<T> = T extends Iterable<infer U> ? U : never;
+export function modifyEach<T extends Iterable<unknown>>(
+  values: T,
+  callback: (value: NonNullable<IterableItem<T>>) => void,
+): T {
+  for (const value of values) {
+    if (notNullish(value)) {
+      callback(value as NonNullable<IterableItem<T>>);
+    }
+  }
+  return values;
+}
+
+export function runEach<T extends Iterable<unknown>>(values: T, callback: (value: IterableItem<T>) => void): T {
+  for (const value of values) {
+    callback(value as IterableItem<T>);
+  }
+  return values;
+}
+
+export function transformEach<T, U>(values: Iterable<T>, callback: (value: T) => U): U[] {
+  const result: U[] = [];
+  for (const value of values) {
+    result.push(callback(value));
+  }
+  return result;
+}
+
+export function asVoid(_: unknown): void {
+  // Do nothing
+}

package/src/src/utils/condition.test.ts

@@ -0,0 +1,36 @@
+import "../../_dnt.test_polyfills.js";
+import { expect, fn } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { type Condition, evalCondition } from './condition.js';
+
+describe('evalCondition', () => {
+  it('should return the correct boolean value when condition is true', () => {
+    const condition: Condition = true;
+    const result = evalCondition(condition);
+    expect(result).toBe(true);
+  });
+
+  it('should return the correct boolean value when condition is false', () => {
+    const condition: Condition = false;
+    const result = evalCondition(condition);
+    expect(result).toBe(false);
+  });
+
+  it('should call the condition function and return the correct boolean value without context', () => {
+    const condition = fn(() => true) as Condition;
+    const result = evalCondition(condition);
+    expect(result).toBe(true);
+    expect(condition).toHaveBeenCalledTimes(1);
+  });
+
+  it('should call the condition function with the provided context and return the correct boolean value', () => {
+    const context = {
+      prop: 5,
+    };
+    const condition = fn((ctx: typeof context) => ctx.prop === 5) as Condition<typeof context>;
+    const result = evalCondition(condition, context);
+    expect(result).toBe(true);
+    expect(condition).toHaveBeenCalledWith(context);
+  });
+});

package/src/src/utils/condition.ts

@@ -0,0 +1,7 @@
+export type Condition<T = never> = boolean | ([T] extends [never] ? () => boolean : (ctx: T) => boolean);
+export function evalCondition(condition: Condition<never>): boolean;
+export function evalCondition<T>(condition: Condition<T>, ctx: T): boolean;
+export function evalCondition<T>(condition: Condition<T>, ctx?: T): boolean {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return typeof condition === 'function' ? condition(ctx!) : condition;
+}

package/src/src/utils/endpoint.utils.test.ts

@@ -0,0 +1,36 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import type { ApiEndpoint } from '../transform/api-types.js';
+import { getEndpointUrlPreview } from './endpoint.utils.js';
+
+describe('getEndpointUrlPreview', () => {
+  it('should return the endpoint path if there are no query parameters', () => {
+    const endpoint = { path: '/foo', parameters: [] } as unknown as ApiEndpoint;
+    expect(getEndpointUrlPreview(endpoint)).toBe('/foo');
+  });
+
+  it('should append query parameters to the endpoint path', () => {
+    const endpoint = {
+      path: '/foo',
+      parameters: [
+        { name: 'bar', target: 'query', required: true },
+        { name: 'baz', target: 'query', required: false },
+      ],
+    } as unknown as ApiEndpoint;
+    expect(getEndpointUrlPreview(endpoint)).toBe('/foo?bar={bar}&[baz={baz}]');
+  });
+
+  it('should handle multiple query parameters', () => {
+    const endpoint = {
+      path: '/foo',
+      parameters: [
+        { name: 'bar', target: 'query', required: true },
+        { name: 'baz', target: 'query', required: false },
+        { name: 'qux', target: 'query', required: true },
+      ],
+    } as unknown as ApiEndpoint;
+    expect(getEndpointUrlPreview(endpoint)).toBe('/foo?bar={bar}&[baz={baz}]&qux={qux}');
+  });
+});

package/src/src/utils/endpoint.utils.ts

@@ -0,0 +1,10 @@
+import type { ApiEndpoint } from '../transform/api-types.js';
+
+export function getEndpointUrlPreview(endpoint: ApiEndpoint): string {
+  let url = endpoint.path;
+  const queryParams = endpoint.parameters.filter((p) => p.target === 'query');
+  if (queryParams.length > 0) {
+    url += '?' + queryParams.map((p) => (p.required ? `${p.name}={${p.name}}` : `[${p.name}={${p.name}}]`)).join('&');
+  }
+  return url;
+}

package/src/src/utils/error.utils.ts

@@ -0,0 +1,3 @@
+export function throwExp(message: string): never {
+  throw new Error(message);
+}

package/src/src/utils/factory.test.ts

@@ -0,0 +1,31 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { Factory } from './factory.js';
+
+describe('Factory', () => {
+  describe('create', () => {
+    it('should create an instance using a constructor', () => {
+      class Foo {
+        constructor(public readonly value: string) {}
+      }
+      const factory = Factory.fromType(Foo);
+      const instance = factory.create('bar');
+      expect(instance).toBeInstanceOf(Foo);
+      expect(instance.value).toBe('bar');
+    });
+
+    it('should create an instance using a factory function', () => {
+      const factory = Factory.fromFn((value: string) => ({ value }));
+      const instance = factory.create('bar');
+      expect(instance).toEqual({ value: 'bar' });
+    });
+
+    it('should return a value', () => {
+      const factory = Factory.fromValue('foo');
+      const instance = factory.create();
+      expect(instance).toBe('foo');
+    });
+  });
+});

package/src/src/utils/factory.ts

@@ -0,0 +1,42 @@
+import type { Constructor } from './type.utils.js';
+
+type FactoryProvider<T, TArgs extends unknown[]> =
+  | {
+    kind: 'ctor';
+    factory: Constructor<T, TArgs>;
+  }
+  | {
+    kind: 'fn';
+    factory: (...args: TArgs) => T;
+  }
+  | {
+    kind: 'value';
+    factory: T;
+  };
+
+export class Factory<T, TArgs extends unknown[]> {
+  constructor(private readonly _provider: FactoryProvider<T, TArgs>) {}
+
+  public create(...args: TArgs): T {
+    switch (this._provider.kind) {
+      case 'ctor':
+        return new this._provider.factory(...args);
+      case 'fn':
+        return this._provider.factory(...args);
+      case 'value':
+        return this._provider.factory;
+    }
+  }
+
+  public static fromType<T, TArgs extends unknown[]>(type: Constructor<T, TArgs>): Factory<T, TArgs> {
+    return new Factory({ kind: 'ctor', factory: type });
+  }
+
+  public static fromFn<T, TArgs extends unknown[]>(fn: (...args: TArgs) => T): Factory<T, TArgs> {
+    return new Factory({ kind: 'fn', factory: fn });
+  }
+
+  public static fromValue<T>(value: T): Factory<T, []> {
+    return new Factory({ kind: 'value', factory: value });
+  }
+}

package/src/src/utils/file-system.utils.ts

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import type { Nullable } from './type.utils.js';
+
+export type DirectoryScanOptions = {
+  recursive: boolean;
+  maxDepth: Nullable<number>;
+  filter?: (file: string) => boolean;
+};
+
+export const defaultDirectoryScanOptions: DirectoryScanOptions = {
+  recursive: false,
+  maxDepth: 5,
+};
+
+export async function getFiles(dir: string, options?: Partial<DirectoryScanOptions>): Promise<string[]> {
+  const opts = { ...defaultDirectoryScanOptions, ...options };
+  const files: string[] = [];
+  await getFilesImpl(dir, opts, files, 0);
+  return files;
+}
+
+async function getFilesImpl(
+  dir: string,
+  options: DirectoryScanOptions,
+  files: string[],
+  currentDepth: number,
+): Promise<void> {
+  const dirFiles = await fs.readdir(dir);
+  for (const file of dirFiles) {
+    const filePath = resolve(dir, file);
+    const stat = await fs.lstat(filePath);
+    if (stat.isDirectory()) {
+      if (options.recursive) {
+        if (options.maxDepth && options.maxDepth > currentDepth) {
+          getFilesImpl(filePath, options, files, currentDepth + 1);
+        }
+      }
+    } else {
+      if (!options.filter || options.filter(file)) {
+        files.push(filePath);
+      }
+    }
+  }
+}

package/src/src/utils/generator.utils.test.ts

@@ -0,0 +1,16 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { getInitializedValue } from './generator.utils.js';
+
+describe('getInitializedValue', () => {
+  it('should return the value if it is not undefined', () => {
+    const value = 'test';
+    expect(getInitializedValue(value)).toEqual(value);
+  });
+
+  it('should throw an error if the value is undefined', () => {
+    expect(() => getInitializedValue(undefined)).toThrow('Generator not initialized.');
+  });
+});

package/src/src/utils/generator.utils.ts

@@ -0,0 +1,6 @@
+export function getInitializedValue<T>(value: T | undefined): T {
+  if (value === undefined) {
+    throw new Error('Generator not initialized.');
+  }
+  return value;
+}

package/src/src/utils/object.utils.test.ts

@@ -0,0 +1,33 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { createOverwriteProxy } from './object.utils.js';
+
+describe('createOverwriteProxy', () => {
+  it('should return an object that overwrites specified properties', () => {
+    const obj = { a: 1, b: 2 };
+    const proxy = createOverwriteProxy(obj);
+    proxy.a = 3;
+    expect(proxy.a).toEqual(3);
+    expect(obj.a).toEqual(1);
+  });
+
+  it('should return an object that does not overwrite unspecified properties', () => {
+    const obj = { a: 1, b: 2 };
+    const proxy = createOverwriteProxy(obj);
+    proxy.a = 3;
+    expect(proxy.b).toEqual(2);
+    expect(obj.b).toEqual(2);
+  });
+
+  it('should return an object that gets updates to non overwritten properties', () => {
+    const obj = { a: 1, b: 2 };
+    const proxy = createOverwriteProxy(obj);
+    proxy.a = 3;
+    obj.a = 2;
+    obj.b = 4;
+    expect(proxy.a).toEqual(3);
+    expect(proxy.b).toEqual(4);
+  });
+});

package/src/src/utils/object.utils.ts

@@ -0,0 +1,32 @@
+export function createOverwriteProxy<T extends object>(target: T, values?: Partial<T>): T {
+  const proxy = new Proxy(target, new OverwriteProxyHandler());
+  if (values) {
+    Object.assign(proxy, values);
+  }
+  return proxy;
+}
+
+export function getDeepProperty(obj: object, path: string[]): unknown {
+  let current = obj;
+  for (const key of path) {
+    if (!current || typeof current !== 'object') {
+      return undefined;
+    }
+    // deno-lint-ignore no-explicit-any
+    current = (current as any)[key];
+  }
+  return current;
+}
+
+class OverwriteProxyHandler<T extends object> implements ProxyHandler<T> {
+  private readonly _overwrittenValues: Record<PropertyKey, unknown> = {};
+
+  public get(target: T, prop: PropertyKey): unknown {
+    return this._overwrittenValues[prop] ?? (target as Record<PropertyKey, unknown>)[prop];
+  }
+
+  public set(_target: T, prop: PropertyKey, value: unknown): boolean {
+    this._overwrittenValues[prop] = value;
+    return true;
+  }
+}

package/src/src/utils/schema.utils.test.ts

@@ -0,0 +1,87 @@
+import "../../_dnt.test_polyfills.js";
+import { expect } from '../../deps/jsr.io/@std/expect/1.0.5/mod.js';
+import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.3/bdd.js';
+
+import { createCombinedSchema, createStringSchema } from '../../tests/schema-factory.js';
+import { resolveAnyOfAndAllOf } from './schema.utils.js';
+
+describe('resolveAnyOfAndAllOf', () => {
+  it('should return undefined if the schema is not valid for merge and ignoreNonObjectParts is false', () => {
+    const schema = createCombinedSchema({
+      anyOf: [createStringSchema()],
+    });
+
+    const result = resolveAnyOfAndAllOf(schema, false);
+    expect(result).toBeUndefined();
+  });
+
+  // TODO: Uncomment as soon as @std/expect has new version (https://github.com/denoland/std/pull/6065)
+  // it('should resolve schema from allOf and anyOf', () => {
+  //   const schema = createObjectSchema({
+  //     name: 'root',
+  //     properties: [createUnknownProperty('prop0')],
+  //     required: ['prop0'],
+  //     allOf: [createObjectSchema({ properties: [createUnknownProperty('prop1')], required: ['prop1'] })],
+  //     anyOf: [createObjectSchema({ properties: [createUnknownProperty('prop2')], required: ['prop2'] })],
+  //   });
+
+  //   const expectedResult = expect.objectContaining(
+  //     createObjectSchema({
+  //       name: 'root',
+  //       properties: [
+  //         expect.objectContaining(createUnknownProperty('prop0')),
+  //         expect.objectContaining(createUnknownProperty('prop1')),
+  //         expect.objectContaining(createUnknownProperty('prop2')),
+  //       ],
+  //       required: ['prop0', 'prop1', 'prop2'],
+  //     }),
+  //   );
+
+  //   const result = resolveAnyOfAndAllOf(schema, true);
+  //   expect(result).toEqual(expectedResult);
+  // });
+
+  // TODO: Uncomment as soon as @std/expect has new version (https://github.com/denoland/std/pull/6065)
+  // it('should merge properties from allOf and anyOf recursively', () => {
+  //   const schema = createCombinedSchema({
+  //     name: 'root',
+  //     allOf: [
+  //       createObjectSchema({
+  //         properties: [createUnknownProperty('prop1')],
+  //         required: ['prop1'],
+  //       }),
+  //     ],
+  //     anyOf: [
+  //       createCombinedSchema({
+  //         allOf: [
+  //           createObjectSchema({
+  //             properties: [createUnknownProperty('prop2')],
+  //             required: ['prop2'],
+  //           }),
+  //         ],
+  //         anyOf: [
+  //           createObjectSchema({
+  //             properties: [createUnknownProperty('prop3')],
+  //             required: ['prop3'],
+  //           }),
+  //         ],
+  //       }),
+  //     ],
+  //   });
+
+  //   const expectedResult = expect.objectContaining(
+  //     createObjectSchema({
+  //       name: 'root',
+  //       properties: [
+  //         expect.objectContaining(createUnknownProperty('prop1')),
+  //         expect.objectContaining(createUnknownProperty('prop2')),
+  //         expect.objectContaining(createUnknownProperty('prop3')),
+  //       ],
+  //       required: ['prop1'],
+  //     }),
+  //   );
+
+  //   const result = resolveAnyOfAndAllOf(schema, true);
+  //   expect(result).toEqual(expectedResult);
+  // });
+});