chore(core/schema): deprecate prototyped schemas

Author: kuhe

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

@@ -10,6 +10,7 @@ import type {
   OperationSchema,
   ResponseMetadata,
   SerdeFunctions,
+  StaticErrorSchema,
 } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 
@@ -104,9 +105,9 @@ export class SmithyRpcV2CborProtocol extends RpcProtocol {
 
     const registry = TypeRegistry.for(namespace);
 
-    let errorSchema: ErrorSchema;
+    let errorSchema: StaticErrorSchema;
     try {
-      errorSchema = registry.getSchema(errorName) as ErrorSchema;
+      errorSchema = registry.getSchema(errorName) as StaticErrorSchema;
     } catch (e) {
       if (dataObject.Message) {
         dataObject.message = dataObject.Message;

packages/core/src/submodules/event-streams/EventStreamSerde.ts

@@ -10,6 +10,7 @@ import type {
   SerdeFunctions,
   ShapeDeserializer,
   ShapeSerializer,
+  StaticStructureSchema,
 } from "@smithy/types";
 import { fromUtf8 } from "@smithy/util-utf8";
 
@@ -233,8 +234,8 @@ export class EventStreamSerde {
     let explicitPayloadContentType: undefined | string;
 
     const isKnownSchema = (() => {
-      const struct = unionSchema.getSchema() as StructureSchema;
-      return struct.memberNames.includes(unionMember);
+      const struct = unionSchema.getSchema() as StaticStructureSchema;
+      return struct[4].includes(unionMember);
     })();
     const additionalHeaders: MessageHeaders = {};
 

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

@@ -1,5 +1,5 @@
 import type { EventStreamSerde } from "@smithy/core/event-streams";
-import { NormalizedSchema } from "@smithy/core/schema";
+import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
 import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
 import type {
   ClientProtocol,
@@ -109,10 +109,11 @@ export abstract class HttpProtocol extends SerdeContext implements ClientProtoco
     operationSchema: OperationSchema,
     input: Input
   ): void {
-    const operationNs = NormalizedSchema.of(operationSchema);
     const inputNs = NormalizedSchema.of(operationSchema.input);
-    if (operationNs.getMergedTraits().endpoint) {
-      let hostPrefix = operationNs.getMergedTraits().endpoint?.[0];
+    const opTraits = translateTraits(operationSchema?.traits ?? {});
+
+    if (opTraits.endpoint) {
+      let hostPrefix = opTraits.endpoint?.[0];
       if (typeof hostPrefix === "string") {
         const hostLabelInputs = [...inputNs.structIterator()].filter(
           ([, member]) => member.getMergedTraits().hostLabel

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

@@ -13,7 +13,7 @@ export class TypeRegistry {
   private constructor(
     public readonly namespace: string,
     private schemas: Map<string, ISchema> = new Map(),
-    private exceptions: Map<ErrorSchema | StaticErrorSchema, any> = new Map()
+    private exceptions: Map<StaticErrorSchema, any> = new Map()
   ) {}
 
   /**
@@ -53,16 +53,17 @@ export class TypeRegistry {
   /**
    * Associates an error schema with its constructor.
    */
-  public registerError(es: ErrorSchema | StaticErrorSchema, ctor: any) {
+  public registerError(es: StaticErrorSchema, ctor: any) {
     this.exceptions.set(es, ctor);
+    this.register(es[1] + "#" + es[2], es);
   }
 
   /**
    * @param es - query.
    * @returns Error constructor that extends the service's base exception.
    */
   public getErrorCtor(es: ErrorSchema | StaticErrorSchema): any {
-    return this.exceptions.get(es);
+    return this.exceptions.get(es as StaticErrorSchema);
   }
 
   /**
@@ -78,10 +79,14 @@ export class TypeRegistry {
    *
    * @returns the synthetic base exception of the service namespace associated with this registry instance.
    */
-  public getBaseException(): ErrorSchema | undefined {
-    for (const [id, schema] of this.schemas.entries()) {
-      if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
-        return schema as ErrorSchema;
+  public getBaseException(): StaticErrorSchema | undefined {
+    for (const exceptionKey of this.exceptions.keys()) {
+      if (Array.isArray(exceptionKey)) {
+        const [, ns, name] = exceptionKey;
+        const id = ns + "#" + name;
+        if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+          return exceptionKey;
+        }
       }
     }
     return undefined;

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

@@ -3,6 +3,7 @@ export * from "./middleware/getSchemaSerdePlugin";
 export * from "./schemas/ListSchema";
 export * from "./schemas/MapSchema";
 export * from "./schemas/OperationSchema";
+export * from "./schemas/operation";
 export * from "./schemas/ErrorSchema";
 export * from "./schemas/NormalizedSchema";
 export * from "./schemas/Schema";

packages/core/src/submodules/schema/middleware/schemaDeserializationMiddleware.ts

@@ -4,12 +4,11 @@ import type {
   DeserializeHandlerArguments,
   HandlerExecutionContext,
   MetadataBearer,
-  OperationSchema,
   StaticOperationSchema,
 } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 
-import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
+import { operation } from "../schemas/operation";
 import type { PreviouslyResolved } from "./schema-middleware-types";
 
 /**
@@ -20,16 +19,14 @@ export const schemaDeserializationMiddleware =
   (next: DeserializeHandler<any, any>, context: HandlerExecutionContext) =>
   async (args: DeserializeHandlerArguments<any>) => {
     const { response } = await next(args);
-    let { operationSchema } = getSmithyContext(context) as {
-      operationSchema: OperationSchema | StaticOperationSchema;
+    const { operationSchema } = getSmithyContext(context) as {
+      operationSchema: StaticOperationSchema;
     };
-    if (isStaticSchema(operationSchema)) {
-      operationSchema = hydrate(operationSchema);
-    }
+    const [, ns, n, t, i, o] = operationSchema;
 
     try {
       const parsed = await config.protocol.deserializeResponse(
-        operationSchema,
+        operation(ns, n, t, i, o),
         {
           ...config,
           ...context,

packages/core/src/submodules/schema/middleware/schemaSerializationMiddleware.ts

@@ -2,15 +2,14 @@ import type {
   Endpoint,
   EndpointBearer,
   HandlerExecutionContext,
-  OperationSchema as IOperationSchema,
   Provider,
   SerializeHandler,
   SerializeHandlerArguments,
   StaticOperationSchema,
 } from "@smithy/types";
 import { getSmithyContext } from "@smithy/util-middleware";
 
-import { hydrate, isStaticSchema } from "../schemas/NormalizedSchema";
+import { operation } from "../schemas/operation";
 import type { PreviouslyResolved } from "./schema-middleware-types";
 
 /**
@@ -20,19 +19,17 @@ export const schemaSerializationMiddleware =
   (config: PreviouslyResolved) =>
   (next: SerializeHandler<any, any>, context: HandlerExecutionContext) =>
   async (args: SerializeHandlerArguments<any>) => {
-    let { operationSchema } = getSmithyContext(context) as {
-      operationSchema: IOperationSchema | StaticOperationSchema;
+    const { operationSchema } = getSmithyContext(context) as {
+      operationSchema: StaticOperationSchema;
     };
-    if (isStaticSchema(operationSchema)) {
-      operationSchema = hydrate(operationSchema);
-    }
+    const [, ns, n, t, i, o] = operationSchema;
 
     const endpoint: Provider<Endpoint> =
       context.endpointV2?.url && config.urlParser
         ? async () => config.urlParser!(context.endpointV2!.url as URL)
         : (config as unknown as EndpointBearer).endpoint!;
 
-    const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+    const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
       ...config,
       ...context,
       endpoint,

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

@@ -10,6 +10,7 @@ import { StructureSchema } from "./StructureSchema";
  * by additionally holding the class reference for the corresponding ServiceException class.
  *
  * @alpha
+ * @deprecated use StaticSchema
  */
 export class ErrorSchema extends StructureSchema {
   public static readonly symbol = Symbol.for("@smithy/err");
@@ -24,6 +25,7 @@ export class ErrorSchema extends StructureSchema {
  * Factory for ErrorSchema, to reduce codegen output and register the schema.
  *
  * @internal
+ * @deprecated use StaticSchema
  *
  * @param namespace - shapeId namespace.
  * @param name - shapeId name.

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

@@ -7,6 +7,7 @@ import { Schema } from "./Schema";
  * The deprecated Set type may be represented as a list.
  *
  * @alpha
+ * @deprecated use StaticSchema
  */
 export class ListSchema extends Schema implements IListSchema {
   public static readonly symbol = Symbol.for("@smithy/lis");
@@ -20,6 +21,7 @@ export class ListSchema extends Schema implements IListSchema {
  * Factory for ListSchema.
  *
  * @internal
+ * @deprecated use StaticSchema
  */
 export const list = (namespace: string, name: string, traits: SchemaTraits, valueSchema: SchemaRef): ListSchema =>
   Schema.assign(new ListSchema(), {

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

@@ -5,6 +5,7 @@ import { Schema } from "./Schema";
 /**
  * A schema with a key schema and value schema.
  * @alpha
+ * @deprecated use StaticSchema
  */
 export class MapSchema extends Schema implements IMapSchema {
   public static readonly symbol = Symbol.for("@smithy/map");
@@ -21,6 +22,7 @@ export class MapSchema extends Schema implements IMapSchema {
 /**
  * Factory for MapSchema.
  * @internal
+ * @deprecated use StaticSchema
  */
 export const map = (
   namespace: string,