@goast/core 0.4.2 → 0.5.0-beta.1

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,142 +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))),
-  );
-}
-
-/**
- * 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);
-}