@goast/core 0.5.3 → 0.6.0-beta.1

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

@@ -1,58 +0,0 @@
-// 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/api-data.utils.ts

@@ -1,48 +0,0 @@
-import { dirname, relative } from 'node:path';
-import process from 'node:process';
-import type { ApiComponent, ApiData } from '../transform/api-types.js';
-
-const DOCUMENTS_BASE_PATH = Symbol('documentsBasePath');
-
-type ApiDataWithBasePath = ApiData & {
-  [DOCUMENTS_BASE_PATH]?: string;
-};
-
-export function getSourceDisplayName<T>(data: ApiData, component: ApiComponent<T>): string {
-  let basePath: string | undefined = (data as ApiDataWithBasePath)[DOCUMENTS_BASE_PATH];
-  if (basePath === undefined) {
-    const allPaths = data.documents.map((doc) => doc.$src.file);
-    basePath = getCommonBasePath(allPaths);
-    (data as ApiDataWithBasePath)[DOCUMENTS_BASE_PATH] = basePath;
-  }
-
-  const relativePath = relative(basePath, component.$src.file);
-  return `${relativePath}#${component.$src.path}`;
-}
-
-function getCommonBasePath(paths: string[]): string {
-  if (paths.length === 0) return '';
-  if (paths.length === 1) return dirname(paths[0]);
-
-  const splitPaths = paths.map((p) => normalizePath(p).split('/'));
-  const minLength = Math.min(...splitPaths.map((parts) => parts.length));
-  const commonParts: string[] = [];
-
-  for (let i = 0; i < minLength; i++) {
-    const part = splitPaths[0][i];
-    if (splitPaths.every((parts) => parts[i] === part)) {
-      commonParts.push(part);
-    } else {
-      break;
-    }
-  }
-
-  return commonParts.join('/');
-}
-
-function normalizePath(path: string): string {
-  if (process.platform === 'win32') {
-    return path.replace(/\\/g, '/');
-  }
-  return path;
-}

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

@@ -1,7 +0,0 @@
-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

@@ -1,51 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import { basename, resolve } from 'node:path';
-import { fileURLToPath, URL } 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

@@ -1,40 +0,0 @@
-// 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.ts

@@ -1,86 +0,0 @@
-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.ts

@@ -1,7 +0,0 @@
-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.ts

@@ -1,10 +0,0 @@
-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

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

package/src/src/utils/factory.ts

@@ -1,42 +0,0 @@
-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

@@ -1,61 +0,0 @@
-import { dirname, resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import type { OpenApiGeneratorConfig } from '../codegen/config.js';
-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) {
-          await getFilesImpl(filePath, options, files, currentDepth + 1);
-        }
-      }
-    } else {
-      if (!options.filter || options.filter(file)) {
-        files.push(filePath);
-      }
-    }
-  }
-}
-
-export function writeGeneratedFile(config: OpenApiGeneratorConfig, filePath: string, content: string): void {
-  if (config.existingFileBehavior !== 'override' && fs.existsSync(filePath)) {
-    if (config.existingFileBehavior === 'error') {
-      throw new Error(`File already exists: ${filePath}`);
-    }
-    return;
-  }
-
-  fs.ensureDirSync(dirname(filePath));
-  fs.writeFileSync(filePath, content);
-}

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

@@ -1,6 +0,0 @@
-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.ts

@@ -1,32 +0,0 @@
-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.ts

@@ -1,148 +0,0 @@
-import { isOpenApiObjectProperty } from '../internal-utils.js';
-import type { OpenApiSchema } from '../parse/openapi-types.js';
-import type { ApiSchema, ApiSchemaProperty, ObjectLikeApiSchema } from '../transform/api-types.js';
-
-export function resolveAnyOfAndAllOf(
-  schema: ApiSchema<'combined' | 'object'>,
-  ignoreNonObjectParts: boolean,
-): ApiSchema<'object'> | undefined {
-  if (!ignoreNonObjectParts && (hasInvalidSubSchema(schema.anyOf) || hasInvalidSubSchema(schema.allOf))) {
-    return undefined;
-  }
-
-  const required = new Set(schema.required);
-  const properties = new Map<string, ApiSchemaProperty>();
-  if ('properties' in schema) {
-    schema.properties.forEach((prop) => properties.set(prop.name, prop));
-  }
-  collectSubSchemaProperties(schema.allOf, properties, required, false);
-  collectSubSchemaProperties(schema.anyOf, properties, required, true);
-
-  const initialAdditionalProperties = schema.kind === 'object' ? schema.additionalProperties : undefined;
-  let additionalProperties = initialAdditionalProperties;
-  additionalProperties = combineAdditionalProperties(schema.allOf, additionalProperties);
-  additionalProperties = combineAdditionalProperties(schema.anyOf, additionalProperties);
-
-  if (properties.size === 0 && initialAdditionalProperties === additionalProperties) {
-    return undefined;
-  }
-
-  return {
-    ...schema,
-    kind: 'object',
-    type: 'object',
-    anyOf: [],
-    allOf: [],
-    properties: properties,
-    required: required,
-    additionalProperties,
-  };
-}
-
-function collectSubSchemaProperties(
-  subSchemas: ApiSchema[],
-  properties: Map<string, ApiSchemaProperty>,
-  required: Set<string>,
-  optional: boolean,
-) {
-  for (const subSchema of subSchemas) {
-    if (subSchema.kind === 'object') {
-      for (const prop of subSchema.properties.values()) {
-        if (!properties.has(prop.name)) {
-          properties.set(prop.name, prop);
-        }
-      }
-      if (!optional) {
-        for (const prop of subSchema.required) {
-          required.add(prop);
-        }
-      }
-    }
-
-    if (subSchema.kind === 'object' || subSchema.kind === 'combined') {
-      collectSubSchemaProperties(subSchema.allOf, properties, required, optional);
-      collectSubSchemaProperties(subSchema.anyOf, properties, required, true);
-    }
-  }
-}
-
-function combineAdditionalProperties(
-  subSchemas: ApiSchema[],
-  current: ObjectLikeApiSchema['additionalProperties'],
-): ObjectLikeApiSchema['additionalProperties'] {
-  if (current === true) return true;
-
-  for (const subSchema of subSchemas) {
-    if (subSchema.kind === 'object' && subSchema.additionalProperties) {
-      if (subSchema.additionalProperties === true) return true;
-      if (!current) {
-        current = subSchema.additionalProperties;
-      } else if (current && current.id !== subSchema.additionalProperties.id) {
-        if (current.kind === 'oneOf') {
-          current.oneOf.push(subSchema.additionalProperties);
-        } else {
-          const id = `schema-${Math.random().toString(36).substring(2)}`;
-          current = {
-            $ref: undefined,
-            $src: current.$src,
-            id,
-            kind: 'oneOf',
-            name: id,
-            isNameGenerated: true,
-            description: undefined,
-            deprecated: false,
-            accessibility: 'all',
-            enum: undefined,
-            const: undefined,
-            default: undefined,
-            example: undefined,
-            nullable: false,
-            required: new Set(),
-            custom: {},
-            not: undefined,
-            discriminator: undefined,
-            inheritedSchemas: [],
-            oneOf: [current, subSchema.additionalProperties],
-          };
-        }
-      }
-    }
-
-    if (subSchema.kind === 'object' || subSchema.kind === 'combined') {
-      current = combineAdditionalProperties(subSchema.allOf, current);
-      current = combineAdditionalProperties(subSchema.anyOf, current);
-    }
-
-    if (current === true) return true;
-  }
-
-  return current;
-}
-
-function hasInvalidSubSchema(subSchemas: ApiSchema[]): boolean {
-  return subSchemas.some(
-    (x) =>
-      x.kind !== 'object' &&
-      (x.kind !== 'combined' || (!hasInvalidSubSchema(x.allOf) && !hasInvalidSubSchema(x.anyOf))),
-  );
-}
-
-export const DEFAULT_IGNORED_SCHEMA_PROPERTIES: (keyof OpenApiSchema)[] = [
-  'description',
-  'example',
-  'deprecated',
-];
-
-/**
- * Retrieves the first schema reference and the reference chain of a given schema that
- * defines some schema properties. (e.g. schemas with just "$ref" are skipped)
- * @param schema The schema to retrieve the reference from.
- * @param propertiesToIgnore The properties to ignore when checking for a schema definition.
- */
-export function getSchemaReference(schema: ApiSchema, propertiesToIgnore: (keyof OpenApiSchema)[]): ApiSchema {
-  if (!schema.$ref) return schema;
-  const hasPropertiesDefined = Object.keys(schema.$src.originalComponent).some(
-    (key) => isOpenApiObjectProperty(key) && !propertiesToIgnore.includes(key as keyof OpenApiSchema),
-  );
-  return hasPropertiesDefined ? schema : getSchemaReference(schema.$ref, propertiesToIgnore);
-}