@goast/core 0.5.0-beta.5 → 0.5.0

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

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

@@ -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.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.ts

@@ -0,0 +1,148 @@
+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);
+}