rework schemas

Author: kuhe

packages/core/src/submodules/cbor/CborCodec.ts

@@ -1,15 +1,6 @@
-import { deref, ListSchema, MapSchema, StructureSchema } from "@smithy/core/schema";
+import { NormalizedSchema } from "@smithy/core/schema";
 import { copyDocumentWithTransform, parseEpochTimestamp } from "@smithy/core/serde";
-import {
-  Codec,
-  MemberSchema,
-  Schema,
-  SchemaRef,
-  SerdeContext,
-  ShapeDeserializer,
-  ShapeSerializer,
-  TraitsSchema,
-} from "@smithy/types";
+import { Codec, Schema, SchemaRef, SerdeContext, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
 
 import { cbor } from "./cbor";
 import { dateToTag } from "./parseCborBody";
@@ -46,17 +37,19 @@ export class CborShapeSerializer implements ShapeSerializer<Uint8Array> {
       if (_ instanceof Date) {
         return dateToTag(_);
       }
-      const schema = deref((schemaRef as MemberSchema)?.[0] ?? schemaRef);
       if (_ instanceof Uint8Array) {
         return _;
       }
-      const sparse = (schema as TraitsSchema)?.traits?.sparse;
+
+      const ns = NormalizedSchema.of(schemaRef);
+      const sparse = !!ns.getMergedTraits().sparse;
+
       if (Array.isArray(_)) {
         if (!sparse) {
           return _.filter((item) => item != null);
         }
       } else if (_ && typeof _ === "object") {
-        if (!sparse) {
+        if (!sparse && ns.isMapSchema()) {
           for (const [k, v] of Object.entries(_)) {
             if (v == null) {
               delete _[k];
@@ -88,15 +81,20 @@ export class CborShapeDeserializer implements ShapeDeserializer {
     return this.readValue(schema, data);
   }
 
-  private readValue(schema: Schema, value: any): any {
-    if (typeof schema === "string") {
-      if (schema === "time" || schema === "epoch-seconds" || schema === "date-time") {
+  private readValue(_schema: Schema, value: any): any {
+    const ns = NormalizedSchema.of(_schema);
+    const schema = ns.getSchema();
+
+    if (typeof schema === "number") {
+      if (ns.isTimestampSchema()) {
+        // format is ignored.
         return parseEpochTimestamp(value);
       }
-      if (schema === "blob" || schema === "streaming-blob") {
+      if (ns.isBlobSchema()) {
         return value;
       }
     }
+
     switch (typeof value) {
       case "undefined":
       case "boolean":
@@ -116,37 +114,27 @@ export class CborShapeDeserializer implements ShapeDeserializer {
         if (value instanceof Date) {
           return value;
         }
-        const traits =
-          Array.isArray(schema) && schema.length >= 2
-            ? {
-                ...(deref((schema as MemberSchema)[0]) as TraitsSchema)?.traits,
-                ...(schema as MemberSchema)[1],
-              }
-            : (deref(schema) as TraitsSchema)?.traits;
 
         if (Array.isArray(value)) {
           const newArray = [];
+          const memberSchema = ns.getMemberSchema();
+          const sparse = ns.isListSchema() && !!ns.getMergedTraits().sparse;
+
           for (const item of value) {
-            newArray.push(this.readValue(schema instanceof ListSchema ? deref(schema.valueSchema) : void 0, item));
-            if (!traits?.sparse) {
-              if (newArray[newArray.length - 1] == null) {
-                newArray.pop();
-              }
+            newArray.push(this.readValue(memberSchema, item));
+            if (!sparse && newArray[newArray.length - 1] == null) {
+              newArray.pop();
             }
           }
           return newArray;
         }
 
         const newObject = {} as any;
         for (const key of Object.keys(value)) {
-          const targetSchema =
-            schema instanceof StructureSchema
-              ? deref(schema.members[key]?.[0])
-              : schema instanceof MapSchema
-                ? deref(schema.valueSchema)
-                : void 0;
+          const targetSchema = ns.isMapSchema() ? ns.getMemberSchema() : ns.getMemberSchema(key);
           newObject[key] = this.readValue(targetSchema, value[key]);
-          if (!traits?.sparse && newObject[key] == null) {
+
+          if (ns.isMapSchema() && newObject[key] == null && !ns.getMergedTraits().sparse) {
             delete newObject[key];
           }
         }

packages/core/src/submodules/protocols/HttpProtocol.ts

@@ -122,13 +122,13 @@ export abstract class HttpProtocol implements Protocol<IHttpRequest, IHttpRespon
       } else if (memberTraits.httpPrefixHeaders) {
         for (const [key, val] of Object.entries(inputMember)) {
           const amalgam = memberTraits.httpPrefixHeaders + key;
-          serializer.write([, { httpHeader: amalgam }], val);
+          serializer.write([0, { httpHeader: amalgam }], val);
           headers[amalgam.toLowerCase()] = String(serializer.flush()).toLowerCase();
         }
         delete _input[memberName];
       } else if (memberTraits.httpQueryParams) {
         for (const [key, val] of Object.entries(inputMember)) {
-          serializer.write([, { httpQuery: key }], val);
+          serializer.write([0, { httpQuery: key }], val);
           query[key] = serializer.flush() as string;
         }
         delete _input[memberName];

packages/core/src/submodules/schema/TypeRegistry.ts

@@ -29,26 +29,13 @@ export class TypeRegistry {
    * @param schema - to be registered.
    */
   public register(shapeId: string, schema: ISchema) {
-    const qualifiedName = this.namespace + "#" + shapeId;
+    const qualifiedName = this.normalizeShapeId(shapeId);
     this.schemas.set(qualifiedName, schema);
     if (typeof schema === "object") {
       TypeRegistry.schemaToRegistry.set(schema, this);
     }
   }
 
-  /**
-   * Used to disambiguate e.g. XML values, which are all strings,
-   * into other simple JavaScript types like boolean and number.
-   *
-   * @param simpleTypes - map of shape id strings to simple type.
-   */
-  public registerSimpleTypes(simpleTypes: Record<string, "boolean" | "number" | "bigint" | "bigdecimal">): void {
-    for (const [name, type] of Object.entries(simpleTypes)) {
-      const normalizedName = name.includes("#") ? name : this.namespace + "#" + name;
-      this.simpleTypes[normalizedName] = type;
-    }
-  }
-
   /**
    * Used to disambiguate e.g. XML values, which are all strings,
    * into other simple JavaScript types like boolean and number.
@@ -57,21 +44,19 @@ export class TypeRegistry {
    * @returns simple type of the shape id in this registry.
    */
   public getSimpleType(shapeId: string): string {
-    if (shapeId.includes("#")) {
-      return this.simpleTypes[shapeId];
-    }
-    return this.simpleTypes[this.namespace + "#" + shapeId] ?? "unknown";
+    return this.simpleTypes[this.normalizeShapeId(shapeId)] ?? "unknown";
   }
 
   /**
    * @param shapeId - query.
    * @returns the schema.
    */
   public getSchema(shapeId: string): ISchema {
-    if (shapeId.includes("#")) {
-      return this.schemas.get(shapeId);
+    const id = this.normalizeShapeId(shapeId);
+    if (!this.schemas.has(id)) {
+      throw new Error(`@smithy/core/schema - schema not found for ${id}`);
     }
-    return this.schemas.get(this.namespace + "#" + shapeId);
+    return this.schemas.get(id)!;
   }
 
   /**
@@ -93,4 +78,11 @@ export class TypeRegistry {
     TypeRegistry.registries.delete(this.namespace);
     this.schemas.clear();
   }
+
+  private normalizeShapeId(shapeId: string) {
+    if (shapeId.includes("#")) {
+      return shapeId;
+    }
+    return this.namespace + "#" + shapeId;
+  }
 }

packages/core/src/submodules/schema/schemas/ErrorSchema.ts

@@ -7,23 +7,25 @@ export class ErrorSchema extends StructureSchema {
   public constructor(
     public name: string,
     public traits: SchemaTraits,
-    public members: Record<string, [SchemaRef, SchemaTraits]>,
+    public memberNames: string[],
+    public memberList: SchemaRef[],
     /**
      * Constructor for a modeled service exception class that extends Error.
      */
     public ctor: any
   ) {
-    super(name, traits, members);
+    super(name, traits, memberNames, memberList);
   }
 }
 
 export function error(
   name: string,
   traits: SchemaTraits = {},
-  members: Record<string, [SchemaRef, SchemaTraits]> = {},
+  memberNames: string[],
+  memberList: SchemaRef[],
   ctor: any
 ): ErrorSchema {
-  const schema = new ErrorSchema(name, traits, members, ctor);
+  const schema = new ErrorSchema(name, traits, memberNames, memberList, ctor);
   if (TypeRegistry.active) {
     TypeRegistry.active.register(name, schema);
   }

packages/core/src/submodules/schema/schemas/ListSchema.ts

@@ -13,7 +13,7 @@ export class ListSchema extends Schema implements IListSchema {
   }
 }
 
-export function list(name: string, traits: SchemaTraits = {}, valueSchema: SchemaRef = void 0): ListSchema {
+export function list(name: string, traits: SchemaTraits = {}, valueSchema: SchemaRef): ListSchema {
   const schema = new ListSchema(name, traits, typeof valueSchema === "function" ? valueSchema() : valueSchema);
   if (TypeRegistry.active) {
     TypeRegistry.active.register(name, schema);

packages/core/src/submodules/schema/schemas/MapSchema.ts

@@ -13,7 +13,7 @@ export class MapSchema extends Schema implements IMapSchema {
   }
 }
 
-export function map(name: string, traits: SchemaTraits = {}, valueSchema: SchemaRef = void 0): MapSchema {
+export function map(name: string, traits: SchemaTraits = {}, valueSchema: SchemaRef): MapSchema {
   const schema = new MapSchema(name, traits, typeof valueSchema === "function" ? valueSchema() : valueSchema);
   if (TypeRegistry.active) {
     TypeRegistry.active.register(name, schema);

packages/core/src/submodules/schema/schemas/NormalizedSchema.ts

@@ -63,27 +63,56 @@ export class NormalizedSchema implements INormalizedSchema {
   }
 
   public isListSchema(): boolean {
-    return this.schema === 2 || this.schema instanceof ListSchema;
+    if (typeof this.schema === "number") {
+      return this.schema >> 6 === 0b01;
+    }
+    return this.schema instanceof ListSchema;
   }
 
   public isMapSchema(): boolean {
-    return this.schema === 4 || this.schema instanceof MapSchema;
+    if (typeof this.schema === "number") {
+      return this.schema >> 6 === 0b10;
+    }
+    return this.schema instanceof MapSchema;
   }
 
   public isStructSchema(): boolean {
     return (
-      this.schema === 8 ||
       (this.schema !== null && typeof this.schema === "object" && "members" in this.schema) ||
       this.schema instanceof StructureSchema
     );
   }
 
   public isBlobSchema(): boolean {
-    return this.schema === "blob" || this.schema === "streaming-blob";
+    return this.schema === 21 || this.schema === 42;
+  }
+
+  public isTimestampSchema(): boolean {
+    return typeof this.schema === "number" && this.schema >= 4 && this.schema <= 7;
+  }
+
+  public isStringSchema(): boolean {
+    return this.schema === 0;
+  }
+
+  public isBooleanSchema(): boolean {
+    return this.schema === 2;
+  }
+
+  public isNumericSchema(): boolean {
+    return this.schema === 1;
+  }
+
+  public isBigIntegerSchema(): boolean {
+    return this.schema === 17;
+  }
+
+  public isBigDecimalSchema(): boolean {
+    return this.schema === 19;
   }
 
   public isStreaming(): boolean {
-    return !!this.getMergedTraits().streaming || this.getSchema() === "streaming-blob";
+    return !!this.getMergedTraits().streaming || this.getSchema() === 42;
   }
 
   public getMergedTraits(): SchemaTraits {
@@ -102,22 +131,31 @@ export class NormalizedSchema implements INormalizedSchema {
   }
 
   public getMemberSchema(member?: string): NormalizedSchema {
-    if (typeof this.schema !== "object") {
-      return NormalizedSchema.of(void 0, member as string);
+    if (typeof this.schema === "number" && this.schema >= 0b0010_0000) {
+      return NormalizedSchema.of(0b0011_1111 & this.schema, member as string);
     }
-    if ("members" in (this.schema as StructureSchema)) {
-      if (typeof member === "undefined") {
-        throw new Error("cannot call getMemberSchema(void) with StructureSchema");
+    if (this.schema && typeof this.schema === "object") {
+      const struct = this.schema as StructureSchema;
+      if ("members" in struct) {
+        if (typeof member === "undefined") {
+          throw new Error("cannot call getMemberSchema(void) with StructureSchema");
+        }
+        if (!(member in struct.members)) {
+          throw new Error(
+            `@smithy/core/schema - structure schema has no member ${member}, members are: ${struct.memberNames.join(", ")}`
+          );
+        }
+        return NormalizedSchema.of(struct.members[member], member as string);
       }
-      return NormalizedSchema.of((this.schema as StructureSchema).members[member], member as string);
-    }
-    if ("valueSchema" in (this.schema as MapSchema | ListSchema)) {
-      if (typeof member !== "undefined") {
-        throw new Error("cannot call getMemberSchema(string) with List or Map Schema");
+      const collection = this.schema as MapSchema | ListSchema;
+      if ("valueSchema" in collection) {
+        if (typeof member !== "undefined") {
+          throw new Error("cannot call getMemberSchema(string) with List or Map Schema");
+        }
+        return NormalizedSchema.of(collection.valueSchema);
       }
-      return NormalizedSchema.of((this.schema as MapSchema | ListSchema).valueSchema);
     }
-    return NormalizedSchema.of(void 0, member as string);
+    throw new Error("@smithy/core/schema - the schema does not have members.");
   }
 
   public getMemberSchemas(): Record<string, NormalizedSchema> {

packages/core/src/submodules/schema/schemas/StructureSchema.ts

@@ -1,24 +1,33 @@
-import type { SchemaRef, SchemaTraits, StructureSchema as IStructureSchema } from "@smithy/types";
+import type { MemberSchema, SchemaRef, SchemaTraits, StructureSchema as IStructureSchema } from "@smithy/types";
 
 import { TypeRegistry } from "../TypeRegistry";
 import { Schema } from "./Schema";
 
 export class StructureSchema extends Schema implements IStructureSchema {
+  public members: Record<string, [SchemaRef, SchemaTraits]> = {};
+
   public constructor(
     public name: string,
     public traits: SchemaTraits,
-    public members: Record<string, [SchemaRef, SchemaTraits]>
+    public memberNames: string[],
+    public memberList: SchemaRef[]
   ) {
     super(name, traits);
+    for (let i = 0; i < memberNames.length; ++i) {
+      this.members[memberNames[i]] = Array.isArray(memberList[i])
+        ? (memberList[i] as MemberSchema)
+        : [memberList[i], {}];
+    }
   }
 }
 
 export function struct(
   name: string,
   traits: SchemaTraits = {},
-  members: Record<string, [SchemaRef, SchemaTraits]> = {}
+  memberNames: string[],
+  memberList: SchemaRef[]
 ): StructureSchema {
-  const schema = new StructureSchema(name, traits, members);
+  const schema = new StructureSchema(name, traits, memberNames, memberList);
   if (TypeRegistry.active) {
     TypeRegistry.active.register(name, schema);
   }

packages/types/src/index.ts

@@ -22,6 +22,7 @@ export * from "./profile";
 export * from "./response";
 export * from "./retry";
 export * from "./schema/schema";
+export * from "./schema/sentinels";
 export * from "./serde";
 export * from "./shapes";
 export * from "./signature";