@goast/core 0.4.1-springwebclient1 → 0.4.2

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