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.isStructSchema()) {
           for (const [k, v] of Object.entries(_)) {
             if (v == null) {
               delete _[k];
@@ -65,6 +58,7 @@ export class CborShapeSerializer implements ShapeSerializer<Uint8Array> {
           return _;
         }
       }
+
       return _;
     });
   }
@@ -88,15 +82,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,38 +115,36 @@ 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.getValueSchema();
+          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;
-          newObject[key] = this.readValue(targetSchema, value[key]);
-          if (!traits?.sparse && newObject[key] == null) {
-            delete newObject[key];
+          if (ns.isMapSchema() || ns.isDocumentSchema()) {
+            const targetSchema = ns.getValueSchema();
+            newObject[key] = this.readValue(targetSchema, value[key]);
+
+            if (ns.isMapSchema() && newObject[key] == null && !ns.getMergedTraits().sparse) {
+              delete newObject[key];
+            }
+          } else if (ns.isStructSchema()) {
+            const targetSchema = ns.getMemberSchema(key);
+            if (targetSchema === undefined) {
+              continue;
+            }
+            newObject[key] = this.readValue(targetSchema, value[key]);
           }
         }
         return newObject;

packages/core/src/submodules/cbor/SmithyRpcV2CborProtocol.spec.ts

@@ -154,10 +154,10 @@ describe(SmithyRpcV2CborProtocol.name, () => {
         const protocol = new SmithyRpcV2CborProtocol();
         const httpRequest = await protocol.serializeRequest(
           {
+            name: "dummy",
             input: testCase.schema,
             output: void 0,
             traits: {},
-            errors: [],
           },
           testCase.input,
           {
@@ -249,10 +249,10 @@ describe(SmithyRpcV2CborProtocol.name, () => {
         const protocol = new SmithyRpcV2CborProtocol();
         const output = await protocol.deserializeResponse(
           {
+            name: "dummy",
             input: void 0,
             output: testCase.schema,
             traits: {},
-            errors: [],
           },
           {},
           new HttpResponse({

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

@@ -1,4 +1,4 @@
-import { HttpInterceptingShapeSerializer,HttpProtocol } from "@smithy/core/protocols";
+import { HttpInterceptingShapeSerializer, HttpProtocol } from "@smithy/core/protocols";
 import { deref, ErrorSchema, OperationSchema, TypeRegistry } from "@smithy/core/schema";
 import type {
   HandlerExecutionContext,
@@ -36,6 +36,10 @@ export class SmithyRpcV2CborProtocol extends HttpProtocol {
       delete request.body;
       delete request.headers["content-type"];
     } else {
+      if (!request.body) {
+        this.serializer.write(15, {})
+        request.body = this.serializer.flush();
+      }
       try {
         request.headers["content-length"] = String((request.body as Uint8Array).byteLength);
       } catch (e) {}
@@ -82,6 +86,7 @@ export class SmithyRpcV2CborProtocol extends HttpProtocol {
       // TODO(schema) throw client base exception using the dataObject.
       throw new Error("schema not found for " + error);
     }
+
     const message = dataObject.message ?? dataObject.Message ?? "Unknown";
     const exception = new errorSchema.ctor(message);
     Object.assign(exception, {

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

@@ -87,6 +87,9 @@ export abstract class HttpProtocol implements Protocol<IHttpRequest, IHttpRespon
 
     for (const memberName of Object.keys(_input)) {
       const memberNs = ns.getMemberSchema(memberName);
+      if (memberNs === undefined) {
+        continue;
+      }
       const memberSchema = memberNs.getSchema();
       const memberTraits = memberNs.getMergedTraits();
       const inputMember = (_input as any)[memberName] as any;
@@ -122,13 +125,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];
@@ -178,6 +181,16 @@ export abstract class HttpProtocol implements Protocol<IHttpRequest, IHttpRespon
     const schema = ns.getSchema() as StructureSchema;
 
     let dataObject: any = {};
+
+    if (response.statusCode >= 300) {
+      const bytes: Uint8Array = await collectBody(response.body, context as SerdeContext);
+      if (bytes.byteLength > 0) {
+        Object.assign(dataObject, await deserializer.read(15, bytes));
+      }
+      await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+      throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
+    }
+
     let hasNonHttpBindingMember = false;
 
     for (const header in response.headers) {
@@ -188,6 +201,9 @@ export abstract class HttpProtocol implements Protocol<IHttpRequest, IHttpRespon
 
     for (const [memberName] of Object.entries(schema?.members ?? {})) {
       const memberSchema = ns.getMemberSchema(memberName);
+      if (memberSchema === undefined) {
+        continue;
+      }
       const memberSchemas = memberSchema.getMemberSchemas();
       const memberTraits = memberSchema.getMemberTraits();
 
@@ -261,10 +277,6 @@ export abstract class HttpProtocol implements Protocol<IHttpRequest, IHttpRespon
       }
     }
 
-    if (response.statusCode >= 300) {
-      await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
-    }
-
     const output: Output = {
       $metadata: this.deserializeMetadata(response),
       ...dataObject,

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/index.ts

@@ -6,5 +6,6 @@ export * from "./schemas/OperationSchema";
 export * from "./schemas/ErrorSchema";
 export * from "./schemas/NormalizedSchema";
 export * from "./schemas/Schema";
+export * from "./schemas/SimpleSchema";
 export * from "./schemas/StructureSchema";
 export * from "./TypeRegistry";

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,60 @@ 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 isDocumentSchema(): boolean {
+    return this.schema === 15;
   }
 
   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 {
@@ -101,34 +134,55 @@ export class NormalizedSchema implements INormalizedSchema {
     return this.traits;
   }
 
-  public getMemberSchema(member?: string): NormalizedSchema {
-    if (typeof this.schema !== "object") {
-      return NormalizedSchema.of(void 0, member as string);
+  public getValueSchema(): NormalizedSchema {
+    if (typeof this.schema === "number" && this.schema >= 0b0010_0000) {
+      return NormalizedSchema.of(0b0011_1111 & this.schema);
     }
-    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") {
+      if (this.isStructSchema()) {
+        throw new Error("cannot call getValueSchema() with StructureSchema");
+      }
+      const collection = this.schema as MapSchema | ListSchema;
+      if ("valueSchema" in collection) {
+        return NormalizedSchema.of(collection.valueSchema);
       }
-      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");
+    if (this.isDocumentSchema()) {
+      return NormalizedSchema.of(15);
+    }
+    throw new Error("@smithy/core/schema - the schema does not have a value member.");
+  }
+
+  public getMemberSchema(member: string): NormalizedSchema | undefined {
+    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)) {
+          // indicates the member is not recognized.
+          return undefined;
+        }
+        return NormalizedSchema.of(struct.members[member], member as string);
       }
-      return NormalizedSchema.of((this.schema as MapSchema | ListSchema).valueSchema);
     }
-    return NormalizedSchema.of(void 0, member as string);
+    if (this.isDocumentSchema()) {
+      return NormalizedSchema.of(15);
+    }
+    throw new Error("@smithy/core/schema - the schema does not have members.");
   }
 
   public getMemberSchemas(): Record<string, NormalizedSchema> {
     const { schema } = this;
-    if (!schema || typeof schema !== "object") {
+    const struct = schema as StructureSchema;
+    if (!struct || typeof struct !== "object") {
       return {};
     }
-    if ("members" in (schema as StructureSchema)) {
+    if ("members" in struct) {
       const buffer = {} as Record<string, NormalizedSchema>;
-      for (const member of Object.keys((schema as StructureSchema).members)) {
-        buffer[member] = this.getMemberSchema(member);
+      for (const member of struct.memberNames) {
+        buffer[member] = this.getMemberSchema(member)!;
       }
       return buffer;
     }

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

@@ -0,0 +1,22 @@
+import { SchemaRef, SchemaTraits, TraitsSchema } from "@smithy/types";
+
+import { TypeRegistry } from "../TypeRegistry";
+import { Schema } from "./Schema";
+
+export class SimpleSchema extends Schema implements TraitsSchema {
+  public constructor(
+    public name: string,
+    public schemaRef: SchemaRef,
+    public traits: SchemaTraits
+  ) {
+    super(name, traits);
+  }
+}
+
+export function sim(name: string, schemaRef: SchemaRef, traits: SchemaTraits) {
+  const schema = new SimpleSchema(name, schemaRef, traits);
+  if (TypeRegistry.active) {
+    TypeRegistry.active.register(name, schema);
+  }
+  return schema;
+}

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";

packages/types/src/schema/schema.ts

@@ -2,30 +2,39 @@ import { EndpointV2 } from "../endpoint";
 import { HandlerExecutionContext } from "../middleware";
 import { MetadataBearer } from "../response";
 import { SerdeContext } from "../serde";
-
-/**
- * The default schema is a sentinel value
- * indicating that the schema for a shape
- * behaves no differently than a Document.
- *
- * @public
- */
-export type DefaultSchema = undefined;
+import type {
+  BigDecimalSchema,
+  BigIntegerSchema,
+  BlobSchema,
+  BooleanSchema,
+  DocumentSchema,
+  NumericSchema,
+  StreamingBlobSchema,
+  StringSchema,
+  TimestampDateTimeSchema,
+  TimestampDefaultSchema,
+  TimestampEpochSecondsSchema,
+  TimestampHttpDateSchema,
+} from "./sentinels";
 
 /**
  * Sentinel value for Timestamp schema.
  * "time" means unspecified and to use the protocol serializer's default format.
  *
  * @public
  */
-export type TimestampSchema = "time" | "date-time" | "http-date" | "epoch-seconds" | string;
+export type TimestampSchemas =
+  | TimestampDefaultSchema
+  | TimestampDateTimeSchema
+  | TimestampHttpDateSchema
+  | TimestampEpochSecondsSchema
+  | string;
 
 /**
- * Sentinel value for Blob schema.
- *
+ * Sentinel values for Blob schema.
  * @public
  */
-export type BlobSchema = "blob" | "streaming-blob";
+export type BlobSchemas = BlobSchema | StreamingBlobSchema;
 
 /**
  * Signal value for operation Unit input or output.
@@ -74,12 +83,6 @@ export interface StructureSchema extends TraitsSchema {
   members: Record<string, [SchemaRef, SchemaTraits]>;
 }
 
-/**
- * Sentinel value for structure schema with no traits.
- * @public
- */
-export type DefaultStructureSchema = 8;
-
 /**
  * @public
  */
@@ -89,12 +92,6 @@ export interface ListSchema extends TraitsSchema {
   valueSchema: SchemaRef;
 }
 
-/**
- * Sentinel value for list schema with no traits.
- * @public
- */
-export type DefaultListSchema = 2;
-
 /**
  * @public
  */
@@ -104,12 +101,6 @@ export interface MapSchema extends TraitsSchema {
   valueSchema: SchemaRef;
 }
 
-/**
- * Sentinel value for map schema with no traits.
- * @public
- */
-export type DefaultMapSchema = 4;
-
 /**
  * @public
  */
@@ -140,26 +131,52 @@ export interface NormalizedSchema extends TraitsSchema {
   isListSchema(): boolean;
   isMapSchema(): boolean;
   isStructSchema(): boolean;
+  isBlobSchema(): boolean;
+  isTimestampSchema(): boolean;
+  isStringSchema(): boolean;
+  isBooleanSchema(): boolean;
+  isNumericSchema(): boolean;
+  isBigIntegerSchema(): boolean;
+  isBigDecimalSchema(): boolean;
+  isStreaming(): boolean;
   getMergedTraits(): SchemaTraits;
   getMemberTraits(): SchemaTraits;
   getOwnTraits(): SchemaTraits;
-  getMemberSchema(member?: string): NormalizedSchema;
+  /**
+   * For list/set/map.
+   */
+  getValueSchema(): NormalizedSchema;
+  /**
+   * For struct/union.
+   */
+  getMemberSchema(member: string): NormalizedSchema | undefined;
+  getMemberSchemas(): Record<string, NormalizedSchema>;
 }
 
+/**
+ * @public
+ */
+export type SimpleSchema =
+  | BlobSchemas
+  | StringSchema
+  | BooleanSchema
+  | NumericSchema
+  | BigIntegerSchema
+  | BigDecimalSchema
+  | DocumentSchema
+  | TimestampSchemas
+  | number;
+
 /**
  * @public
  */
 export type Schema =
   | UnitSchema
-  | DefaultSchema
-  | TimestampSchema
-  | BlobSchema
+  | TraitsSchema
+  | SimpleSchema
   | ListSchema
-  | DefaultListSchema
   | MapSchema
-  | DefaultMapSchema
   | StructureSchema
-  | DefaultStructureSchema
   | MemberSchema
   | OperationSchema
   | NormalizedSchema;

packages/types/src/schema/sentinels.ts

@@ -0,0 +1,79 @@
+// =============== Simple types ===================
+
+/**
+ * The blob Smithy type, in JS as Uint8Array and other representations
+ * such as Buffer, string, or Readable(Stream) depending on circumstances.
+ * @public
+ */
+export type BlobSchema = 0b0001_0101; // 21
+
+/**
+ * @public
+ */
+export type StreamingBlobSchema = 0b0010_1010; // 42
+
+/**
+ * @public
+ */
+export type BooleanSchema = 0b0000_0010; // 2
+
+/**
+ * Includes string and enum Smithy types.
+ * @public
+ */
+export type StringSchema = 0b0000_0000; // 0
+
+/**
+ * Includes all numeric Smithy types except bigInteger and bigDecimal.
+ * byte, short, integer, long, float, double, intEnum.
+ *
+ * @public
+ */
+export type NumericSchema = 0b0000_0001; // 1
+
+/**
+ * @public
+ */
+export type BigIntegerSchema = 0b0001_0001; // 17
+
+/**
+ * @public
+ */
+export type BigDecimalSchema = 0b0001_0011; // 19
+
+/**
+ * @public
+ */
+export type DocumentSchema = 0b0000_1111; // 15
+
+/**
+ * Smithy type timestamp, in JS as native Date object.
+ * @public
+ */
+export type TimestampDefaultSchema = 0b0000_0100; // 4
+/**
+ * @public
+ */
+export type TimestampDateTimeSchema = 0b0000_0101; // 5
+/**
+ * @public
+ */
+export type TimestampHttpDateSchema = 0b0000_0110; // 6
+/**
+ * @public
+ */
+export type TimestampEpochSecondsSchema = 0b0000_0111; // 7
+
+// =============== Aggregate types ===================
+
+/**
+ * Additional bit indicating the type is a list.
+ * @public
+ */
+export type ListSchemaModifier = 0b0100_0000; // 64
+
+/**
+ * Additional bit indicating the type is a map.
+ * @public
+ */
+export type MapSchemaModifier = 0b1000_0000; // 128

private/smithy-rpcv2-cbor/src/schemas/smithy.api.ts

@@ -1,14 +1,13 @@
-const _B = "Blob";
+const _B = "Byte";
+const _Bl = "Blob";
 const _Bo = "Boolean";
-const _By = "Byte";
 const _D = "Double";
 const _F = "Float";
 const _I = "Integer";
 const _L = "Long";
-const _S = "Short";
+const _S = "String";
+const _Sh = "Short";
 const _T = "Timestamp";
-const _b = "boolean";
-const _n = "number";
 
 // smithy-typescript generated code
 import { TypeRegistry } from "@smithy/core/schema";
@@ -19,19 +18,4 @@ export const smithy_apiRegistry = TypeRegistry.for("smithy.api");
 smithy_apiRegistry.startCapture();
 export var Unit = "unit";
 
-smithy_apiRegistry.registerSimpleTypes({
-  [_Bo]: _b,
-
-  [_By]: _n,
-
-  [_D]: _n,
-
-  [_F]: _n,
-
-  [_I]: _n,
-
-  [_L]: _n,
-
-  [_S]: _n,
-});
 smithy_apiRegistry.stopCapture();

private/smithy-rpcv2-cbor/src/schemas/smithy.framework.ts

@@ -1,10 +1,15 @@
 const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
 const _c = "client";
 const _e = "error";
+const _fL = "fieldList";
+const _m = "message";
+const _p = "path";
 
 // smithy-typescript generated code
 import { ValidationException as __ValidationException } from "../models/index";
-import { TypeRegistry, error as __error } from "@smithy/core/schema";
+import { TypeRegistry, error as __error, list as __list, struct as __struct } from "@smithy/core/schema";
 
 /* eslint no-var: 0 */
 
@@ -15,13 +20,11 @@ export var ValidationException = __error(
   {
     [_e]: _c,
   },
-  {},
+  [_m, _fL],
+  [0, () => ValidationExceptionFieldList],
 
   __ValidationException
 );
-export var ValidationExceptionField = 8 as const;
-
-export var ValidationExceptionFieldList = 2 as const;
-
-smithy_frameworkRegistry.registerSimpleTypes({});
+export var ValidationExceptionField = __struct(_VEF, {}, [_p, _m], [0, 0]);
+export var ValidationExceptionFieldList = __list(_VEFL, {}, () => ValidationExceptionField);
 smithy_frameworkRegistry.stopCapture();

private/smithy-rpcv2-cbor/src/schemas/smithy.protocoltests.rpcv2Cbor.ts

@@ -1,50 +1,58 @@
 const _BL = "BlobList";
+const _BLo = "BooleanList";
 const _DT = "DateTime";
+const _FE = "FooEnum";
+const _FEL = "FooEnumList";
+const _GS = "GreetingStruct";
 const _IE = "IntegerEnum";
+const _IEL = "IntegerEnumList";
+const _IL = "IntegerList";
+const _NSL = "NestedStringList";
+const _SL = "StringList";
+const _SS = "StringSet";
 const _SSL = "SparseStringList";
 const _SSM = "SparseStringMap";
 const _TL = "TimestampList";
-const _n = "number";
+const _h = "hi";
 const _s = "sparse";
 
 // smithy-typescript generated code
-import { TypeRegistry, list as __list, map as __map } from "@smithy/core/schema";
+import { TypeRegistry, list as __list, map as __map, struct as __struct } from "@smithy/core/schema";
 
 /* eslint no-var: 0 */
 
 export const smithy_protocoltests_sharedRegistry = TypeRegistry.for("smithy.protocoltests.shared");
 smithy_protocoltests_sharedRegistry.startCapture();
-export var GreetingStruct = 8 as const;
+export var GreetingStruct = __struct(_GS, {}, [_h], [0]);
+export var BlobList = 64 | 21;
 
-export var BlobList = __list(_BL, {}, [() => "blob", {}]);
-export var BooleanList = 2 as const;
+export var BooleanList = 64 | 2;
 
-export var FooEnumList = 2 as const;
+export var FooEnumList = 64 | 0;
 
-export var IntegerEnumList = 2 as const;
+export var IntegerEnumList = 64 | 1;
 
-export var IntegerList = 2 as const;
-
-export var NestedStringList = 2 as const;
+export var IntegerList = 64 | 1;
 
+export var NestedStringList = __list(_NSL, {}, 64 | 0);
 export var SparseStringList = __list(
   _SSL,
   {
     [_s]: 1,
-  } /* String */
+  },
+  0
 );
-export var StringList = 2 as const;
+export var StringList = 64 | 0;
+
+export var StringSet = 64 | 0;
 
-export var StringSet = 2 as const;
+export var TimestampList = 64 | 4;
 
-export var TimestampList = __list(_TL, {}, [() => "time", {}]);
 export var SparseStringMap = __map(
   _SSM,
   {
     [_s]: 1,
-  } /* String */
+  },
+  0
 );
-smithy_protocoltests_sharedRegistry.registerSimpleTypes({
-  [_IE]: _n,
-});
 smithy_protocoltests_sharedRegistry.stopCapture();

private/smithy-rpcv2-cbor/src/schemas/smithy.protocoltests.shared.ts

@@ -0,0 +1,68 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.typescript.codegen.schema;
+
+import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.knowledge.KnowledgeIndex;
+import software.amazon.smithy.model.shapes.CollectionShape;
+import software.amazon.smithy.model.shapes.MapShape;
+import software.amazon.smithy.model.shapes.MemberShape;
+import software.amazon.smithy.model.shapes.Shape;
+import software.amazon.smithy.model.shapes.ShapeType;
+import software.amazon.smithy.utils.SmithyInternalApi;
+
+/**
+ * Can determine whether a Schema can be defined by a sentinel value.
+ */
+@SmithyInternalApi
+final class SchemaReferenceIndex implements KnowledgeIndex {
+    public final SchemaTraitFilterIndex traits;
+    private final Model model;
+
+    SchemaReferenceIndex(Model model) {
+        this.model = model;
+        traits = SchemaTraitFilterIndex.of(model);
+    }
+
+    public static SchemaReferenceIndex of(Model model) {
+        return model.getKnowledge(SchemaReferenceIndex.class, SchemaReferenceIndex::new);
+    }
+
+    /**
+     * A reference shape is a function pointer to a shape that doesn't have a constant numeric
+     * sentinel value.
+     * Simple non-aggregate types and lists/maps of those types are considered non-reference
+     * in TypeScript.
+     *
+     * @return whether shape is a reference shape.
+     */
+    public boolean isReferenceSchema(Shape shape) {
+        Shape targetShape = shape;
+        if (shape instanceof MemberShape member) {
+            targetShape = model.expectShape(member.getTarget());
+        }
+        ShapeType type = targetShape.getType();
+        switch (type) {
+            case BOOLEAN, STRING, BYTE, DOUBLE, FLOAT, INTEGER, LONG, SHORT, ENUM, INT_ENUM -> {
+                return false;
+            }
+            case TIMESTAMP, BLOB -> {
+                return false;
+            }
+            case LIST, SET, MAP -> {
+                if (shape instanceof CollectionShape collection) {
+                    return isReferenceSchema(collection.getMember());
+                } else if (shape instanceof MapShape map) {
+                    return isReferenceSchema(map.getValue());
+                }
+                return true;
+            }
+            default -> {
+                return true;
+            }
+        }
+    }
+}