chore: schema code size optimization

kuhe · kuhe · commit 9b8805c34032 · 2025-09-04T11:04:57.000-04:00
diff --git a/packages/core/src/submodules/schema/schemas/ErrorSchema.ts b/packages/core/src/submodules/schema/schemas/ErrorSchema.ts
@@ -1,6 +1,7 @@
 import type { SchemaRef, SchemaTraits } from "@smithy/types";
 
 import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
 import { StructureSchema } from "./StructureSchema";
 
 /**
@@ -13,29 +14,8 @@ import { StructureSchema } from "./StructureSchema";
  */
 export class ErrorSchema extends StructureSchema {
   public static symbol = Symbol.for("@smithy/core/schema::ErrorSchema");
+  public ctor!: any;
   protected symbol = ErrorSchema.symbol;
-
-  public constructor(
-    public name: string,
-    public traits: SchemaTraits,
-    public memberNames: string[],
-    public memberList: SchemaRef[],
-    /**
-     * Constructor for a modeled service exception class that extends Error.
-     */
-    public ctor: any
-  ) {
-    super(name, traits, memberNames, memberList);
-  }
-
-  public static [Symbol.hasInstance](lhs: unknown): lhs is ErrorSchema {
-    const isPrototype = ErrorSchema.prototype.isPrototypeOf(lhs as any);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const err = lhs as ErrorSchema;
-      return err.symbol === ErrorSchema.symbol;
-    }
-    return isPrototype;
-  }
 }
 
 /**
@@ -50,15 +30,19 @@ export class ErrorSchema extends StructureSchema {
  * @param memberList - list of schemaRef corresponding to each
  * @param ctor - class reference for the existing Error extending class.
  */
-export function error(
+export const error = (
   namespace: string,
   name: string,
-  traits: SchemaTraits = {},
+  traits: SchemaTraits,
   memberNames: string[],
   memberList: SchemaRef[],
   ctor: any
-): ErrorSchema {
-  const schema = new ErrorSchema(namespace + "#" + name, traits, memberNames, memberList, ctor);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
-}
+): ErrorSchema =>
+  Schema.assign(new ErrorSchema(), {
+    name,
+    namespace,
+    traits,
+    memberNames,
+    memberList,
+    ctor,
+  });
diff --git a/packages/core/src/submodules/schema/schemas/ListSchema.ts b/packages/core/src/submodules/schema/schemas/ListSchema.ts
@@ -1,6 +1,5 @@
 import type { ListSchema as IListSchema, SchemaRef, SchemaTraits } from "@smithy/types";
 
-import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 
 /**
@@ -10,38 +9,22 @@ import { Schema } from "./Schema";
  * @alpha
  */
 export class ListSchema extends Schema implements IListSchema {
-  public static symbol = Symbol.for("@smithy/core/schema::ListSchema");
+  public static symbol = Symbol.for("@smithy/l");
+  public name!: string;
+  public traits!: SchemaTraits;
+  public valueSchema!: SchemaRef;
   protected symbol = ListSchema.symbol;
-
-  public constructor(
-    public name: string,
-    public traits: SchemaTraits,
-    public valueSchema: SchemaRef
-  ) {
-    super(name, traits);
-  }
-
-  public static [Symbol.hasInstance](lhs: unknown): lhs is ListSchema {
-    const isPrototype = ListSchema.prototype.isPrototypeOf(lhs as any);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const list = lhs as ListSchema;
-      return list.symbol === ListSchema.symbol;
-    }
-    return isPrototype;
-  }
 }
 
 /**
  * Factory for ListSchema.
  *
  * @internal
  */
-export function list(namespace: string, name: string, traits: SchemaTraits = {}, valueSchema: SchemaRef): ListSchema {
-  const schema = new ListSchema(
-    namespace + "#" + name,
+export const list = (namespace: string, name: string, traits: SchemaTraits, valueSchema: SchemaRef): ListSchema =>
+  Schema.assign(new ListSchema(), {
+    name,
+    namespace,
     traits,
-    typeof valueSchema === "function" ? valueSchema() : valueSchema
-  );
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
-}
+    valueSchema,
+  });
diff --git a/packages/core/src/submodules/schema/schemas/MapSchema.ts b/packages/core/src/submodules/schema/schemas/MapSchema.ts
@@ -1,55 +1,38 @@
 import type { MapSchema as IMapSchema, SchemaRef, SchemaTraits } from "@smithy/types";
 
-import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 
 /**
  * A schema with a key schema and value schema.
  * @alpha
  */
 export class MapSchema extends Schema implements IMapSchema {
-  public static symbol = Symbol.for("@smithy/core/schema::MapSchema");
+  public static symbol = Symbol.for("@smithy/m");
+  public name!: string;
+  public traits!: SchemaTraits;
+  /**
+   * This is expected to be StringSchema, but may have traits.
+   */
+  public keySchema!: SchemaRef;
+  public valueSchema!: SchemaRef;
   protected symbol = MapSchema.symbol;
-
-  public constructor(
-    public name: string,
-    public traits: SchemaTraits,
-    /**
-     * This is expected to be StringSchema, but may have traits.
-     */
-    public keySchema: SchemaRef,
-    public valueSchema: SchemaRef
-  ) {
-    super(name, traits);
-  }
-
-  public static [Symbol.hasInstance](lhs: unknown): lhs is MapSchema {
-    const isPrototype = MapSchema.prototype.isPrototypeOf(lhs as any);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const map = lhs as MapSchema;
-      return map.symbol === MapSchema.symbol;
-    }
-    return isPrototype;
-  }
 }
 
 /**
  * Factory for MapSchema.
  * @internal
  */
-export function map(
+export const map = (
   namespace: string,
   name: string,
-  traits: SchemaTraits = {},
+  traits: SchemaTraits,
   keySchema: SchemaRef,
   valueSchema: SchemaRef
-): MapSchema {
-  const schema = new MapSchema(
-    namespace + "#" + name,
+): MapSchema =>
+  Schema.assign(new MapSchema(), {
+    name,
+    namespace,
     traits,
     keySchema,
-    typeof valueSchema === "function" ? valueSchema() : valueSchema
-  );
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
-}
+    valueSchema,
+  });
diff --git a/packages/core/src/submodules/schema/schemas/NormalizedSchema.ts b/packages/core/src/submodules/schema/schemas/NormalizedSchema.ts
@@ -36,10 +36,7 @@ export class NormalizedSchema implements INormalizedSchema {
    * @param ref - a polymorphic SchemaRef to be dereferenced/normalized.
    * @param memberName - optional memberName if this NormalizedSchema should be considered a member schema.
    */
-  public constructor(
-    private readonly ref: SchemaRef,
-    private memberName?: string
-  ) {
+  public constructor(private readonly ref: SchemaRef, private memberName?: string) {
     const traitStack = [] as SchemaTraits[];
     let _ref = ref;
     let schema = ref;
@@ -380,7 +377,7 @@ export class NormalizedSchema implements INormalizedSchema {
   public hasMemberSchema(member: string): boolean {
     if (this.isStructSchema()) {
       const struct = this.getSchema() as StructureSchema;
-      return member in struct.members;
+      return struct.memberNames.includes(member);
     }
     return false;
   }
@@ -396,12 +393,14 @@ export class NormalizedSchema implements INormalizedSchema {
   public getMemberSchema(member: string): NormalizedSchema {
     if (this.isStructSchema()) {
       const struct = this.getSchema() as StructureSchema;
-      if (!(member in struct.members)) {
+      if (!struct.memberNames.includes(member)) {
         throw new Error(
           `@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`
         );
       }
-      return NormalizedSchema.memberFrom(struct.members[member], member);
+      const i = struct.memberNames.indexOf(member);
+      const memberSchema = struct.memberList[i];
+      return NormalizedSchema.memberFrom(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], member);
     }
     if (this.isDocumentSchema()) {
       return NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
diff --git a/packages/core/src/submodules/schema/schemas/OperationSchema.ts b/packages/core/src/submodules/schema/schemas/OperationSchema.ts
@@ -1,6 +1,5 @@
 import type { OperationSchema as IOperationSchema, SchemaRef, SchemaTraits } from "@smithy/types";
 
-import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 
 /**
@@ -10,28 +9,29 @@ import { Schema } from "./Schema";
  * @alpha
  */
 export class OperationSchema extends Schema implements IOperationSchema {
-  public constructor(
-    public name: string,
-    public traits: SchemaTraits,
-    public input: SchemaRef,
-    public output: SchemaRef
-  ) {
-    super(name, traits);
-  }
+  public static symbol = Symbol.for("@smithy/o");
+  public name!: string;
+  public traits!: SchemaTraits;
+  public input!: SchemaRef;
+  public output!: SchemaRef;
+  protected symbol = OperationSchema.symbol;
 }
 
 /**
  * Factory for OperationSchema.
  * @internal
  */
-export function op(
+export const op = (
   namespace: string,
   name: string,
-  traits: SchemaTraits = {},
+  traits: SchemaTraits,
   input: SchemaRef,
   output: SchemaRef
-): OperationSchema {
-  const schema = new OperationSchema(namespace + "#" + name, traits, input, output);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
-}
+): OperationSchema =>
+  Schema.assign(new OperationSchema(), {
+    name,
+    namespace,
+    traits,
+    input,
+    output,
+  });
diff --git a/packages/core/src/submodules/schema/schemas/Schema.ts b/packages/core/src/submodules/schema/schemas/Schema.ts
@@ -1,13 +1,34 @@
 import type { SchemaTraits, TraitsSchema } from "@smithy/types";
 
+import { TypeRegistry } from "../TypeRegistry";
+
 /**
  * Abstract base for class-based Schema except NormalizedSchema.
  *
  * @alpha
  */
 export abstract class Schema implements TraitsSchema {
-  protected constructor(
-    public name: string,
-    public traits: SchemaTraits
-  ) {}
+  public name!: string;
+  public namespace!: string;
+  public traits!: SchemaTraits;
+  protected abstract symbol: symbol;
+
+  public static assign<T extends Schema>(instance: T, values: Omit<T, "getName" | "symbol">): T {
+    const schema = Object.assign(instance, values);
+    TypeRegistry.for(schema.namespace).register(schema.name, schema);
+    return schema;
+  }
+
+  public static [Symbol.hasInstance](lhs: unknown) {
+    const isPrototype = this.prototype.isPrototypeOf(lhs as any);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const list = lhs as any;
+      return list.symbol === (this as any).symbol;
+    }
+    return isPrototype;
+  }
+
+  public getName(): string {
+    return this.namespace + "#" + this.name;
+  }
 }
diff --git a/packages/core/src/submodules/schema/schemas/SimpleSchema.ts b/packages/core/src/submodules/schema/schemas/SimpleSchema.ts
@@ -10,34 +10,22 @@ import { Schema } from "./Schema";
  * @alpha
  */
 export class SimpleSchema extends Schema implements TraitsSchema {
-  public static symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
+  public static symbol = Symbol.for("@smithy/s");
+  public name!: string;
+  public schemaRef!: SchemaRef;
+  public traits!: SchemaTraits;
   protected symbol = SimpleSchema.symbol;
-
-  public constructor(
-    public name: string,
-    public schemaRef: SchemaRef,
-    public traits: SchemaTraits
-  ) {
-    super(name, traits);
-  }
-
-  public static [Symbol.hasInstance](lhs: unknown): lhs is SimpleSchema {
-    const isPrototype = SimpleSchema.prototype.isPrototypeOf(lhs as any);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const sim = lhs as SimpleSchema;
-      return sim.symbol === SimpleSchema.symbol;
-    }
-    return isPrototype;
-  }
 }
 
 /**
  * Factory for simple schema class objects.
  *
  * @internal
  */
-export function sim(namespace: string, name: string, schemaRef: SchemaRef, traits: SchemaTraits) {
-  const schema = new SimpleSchema(namespace + "#" + name, schemaRef, traits);
-  TypeRegistry.for(namespace).register(name, schema);
-  return schema;
-}
+export const sim = (namespace: string, name: string, schemaRef: SchemaRef, traits: SchemaTraits) =>
+  Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+  });
diff --git a/packages/core/src/submodules/schema/schemas/StructureSchema.ts b/packages/core/src/submodules/schema/schemas/StructureSchema.ts
diff --git a/packages/types/src/schema/schema.ts b/packages/types/src/schema/schema.ts
