fix(codegen): for static schema

Author: kuhe

.changeset/hungry-mayflies-confess.md

@@ -0,0 +1,6 @@
+---
+"@smithy/core": patch
+"@smithy/types": patch
+---
+
+fix ordering of static simple schema type

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/schema/TypeRegistry.ts

@@ -35,7 +35,8 @@ export class TypeRegistry {
    */
   public register(shapeId: string, schema: ISchema) {
     const qualifiedName = this.normalizeShapeId(shapeId);
-    this.schemas.set(qualifiedName, schema);
+    const registry = TypeRegistry.for(qualifiedName.split("#")[0]);
+    registry.schemas.set(qualifiedName, schema);
   }
 
   /**
@@ -54,15 +55,20 @@ export class TypeRegistry {
    * Associates an error schema with its constructor.
    */
   public registerError(es: ErrorSchema | StaticErrorSchema, ctor: any) {
-    this.exceptions.set(es, ctor);
+    const $error = es as StaticErrorSchema;
+    const registry = TypeRegistry.for($error[1]);
+    registry.schemas.set($error[1] + "#" + $error[2], $error);
+    registry.exceptions.set($error, ctor);
   }
 
   /**
    * @param es - query.
    * @returns Error constructor that extends the service's base exception.
    */
   public getErrorCtor(es: ErrorSchema | StaticErrorSchema): any {
-    return this.exceptions.get(es);
+    const $error = es as StaticErrorSchema;
+    const registry = TypeRegistry.for($error[1]);
+    return registry.exceptions.get(es);
   }
 
   /**
@@ -78,10 +84,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;
@@ -109,8 +119,4 @@ export class TypeRegistry {
     }
     return this.namespace + "#" + shapeId;
   }
-
-  private getNamespace(shapeId: string) {
-    return this.normalizeShapeId(shapeId).split("#")[0];
-  }
 }

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

@@ -43,7 +43,7 @@ import type { OperationSchema } from "./OperationSchema";
 import { op } from "./OperationSchema";
 import { Schema } from "./Schema";
 import type { SimpleSchema } from "./SimpleSchema";
-import { sim } from "./SimpleSchema";
+import { simAdapter } from "./SimpleSchema";
 import { struct, StructureSchema } from "./StructureSchema";
 import { translateTraits } from "./translateTraits";
 
@@ -450,7 +450,7 @@ export function hydrate(
   const [id, ...rest] = ss;
   return (
     {
-      [0 satisfies StaticSchemaIdSimple]: sim,
+      [0 satisfies StaticSchemaIdSimple]: simAdapter,
       [1 satisfies StaticSchemaIdList]: list,
       [2 satisfies StaticSchemaIdMap]: map,
       [3 satisfies StaticSchemaIdStruct]: struct,

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

@@ -15,7 +15,7 @@ export abstract class Schema implements TraitsSchema {
 
   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);
+    // TypeRegistry.for(schema.namespace).register(schema.name, schema);
     return schema;
   }
 

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

@@ -29,3 +29,15 @@ export const sim = (namespace: string, name: string, schemaRef: SchemaRef, trait
     traits,
     schemaRef,
   });
+
+/**
+ * @internal
+ * @deprecated
+ */
+export const simAdapter = (namespace: string, name: string, traits: SchemaTraits, schemaRef: SchemaRef) =>
+  Schema.assign(new SimpleSchema(), {
+    name,
+    namespace,
+    traits,
+    schemaRef,
+  });

packages/types/src/schema/static-schemas.ts

@@ -59,7 +59,7 @@ export type ShapeNamespace = string;
 /**
  * @alpha
  */
-export type StaticSimpleSchema = [StaticSchemaIdSimple, ShapeNamespace, ShapeName, SchemaRef, SchemaTraits];
+export type StaticSimpleSchema = [StaticSchemaIdSimple, ShapeNamespace, ShapeName, SchemaTraits, SchemaRef];
 
 /**
  * @alpha

private/smithy-rpcv2-cbor-schema/src/schemas/schemas_0.ts

@@ -137,7 +137,7 @@ import {
   InvalidGreeting as __InvalidGreeting,
   ValidationException as __ValidationException,
 } from "../models/index";
-import { TypeRegistry, error } from "@smithy/core/schema";
+import { TypeRegistry } from "@smithy/core/schema";
 import {
   StaticErrorSchema,
   StaticListSchema,
@@ -295,26 +295,15 @@ export var RpcV2CborDenseMapsInputOutput: StaticStructureSchema = [
   _RVCDMIO,
   0,
   [_dSM, _dNM, _dBM, _dSMe, _dSMen],
-  [() => DenseStructMap, 128 | 1, 128 | 2, 128 | 0, [2, n1, _DSM, 0, 64 | 0, 64 | 0] as StaticMapSchema],
+  [() => DenseStructMap, 128 | 1, 128 | 2, 128 | 0, [2, n1, _DSM, 0, 0, 64 | 0]],
 ];
 export var RpcV2CborListInputOutput: StaticStructureSchema = [
   3,
   n1,
   _RVCLIO,
   0,
   [_sL, _sS, _iL, _bL, _tL, _eL, _iEL, _nSL, _sLt, _bLl],
-  [
-    64 | 0,
-    64 | 0,
-    64 | 1,
-    64 | 2,
-    64 | 4,
-    64 | 0,
-    64 | 1,
-    [1, n2, _NSL, 0, 64 | 0] as StaticListSchema,
-    () => StructureList,
-    64 | 21,
-  ],
+  [64 | 0, 64 | 0, 64 | 1, 64 | 2, 64 | 4, 64 | 0, 64 | 1, [1, n2, _NSL, 0, 64 | 0], () => StructureList, 64 | 21],
 ];
 export var RpcV2CborSparseMapsInputOutput: StaticStructureSchema = [
   3,
@@ -352,7 +341,7 @@ export var SparseNullsOperationInputOutput: StaticStructureSchema = [
 ];
 export var StructureListMember: StaticStructureSchema = [3, n1, _SLM, 0, [_a, _b_], [0, 0]];
 export var GreetingStruct: StaticStructureSchema = [3, n2, _GS, 0, [_h], [0]];
-export var RpcV2ProtocolServiceException = error(_sC, "RpcV2ProtocolServiceException", 0, [], [], null);
+export var RpcV2ProtocolServiceException: StaticErrorSchema = [-3, _sC, "RpcV2ProtocolServiceException", 0, [], []];
 TypeRegistry.for(_sC).registerError(RpcV2ProtocolServiceException, __RpcV2ProtocolServiceException);
 
 export var ValidationExceptionFieldList: StaticListSchema = [1, n0, _VEFL, 0, () => ValidationExceptionField];

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/schema/SchemaGenerator.java

@@ -276,15 +276,17 @@ private void writeSimpleSchema(Shape shape) {
         TypeScriptWriter writer = getWriter(shape.getId());
         if (elision.traits.hasSchemaTraits(shape)) {
             writer.addImport("StaticSimpleSchema", null, TypeScriptDependency.SMITHY_TYPES);
-            writer.write("""
-                    export var $L: StaticSimpleSchema = [0, $L, $L, $L,""",
+            writer.openBlock("""
+                    export var $L: StaticSimpleSchema = [0, $L, $L,""",
+                ", $L];",
                 getShapeVariableName(shape),
                 checkImportString(shape, shape.getId().getNamespace(), "n"),
                 checkImportString(shape, shape.getId().getName()),
-                resolveSimpleSchema(shape, shape)
+                resolveSimpleSchema(shape, shape),
+                () -> {
+                    writeTraits(shape);
+                }
             );
-            writeTraits(shape);
-            writer.write("];");
         }
     }
 
@@ -341,7 +343,7 @@ private void writeBaseError() {
         String namespace = settings.getService(model).getId().getNamespace();
 
         String exceptionCtorSymbolName = "__" + serviceExceptionName;
-        writer.addImportSubmodule("error", null, TypeScriptDependency.SMITHY_CORE, "/schema");
+        writer.addImport("StaticErrorSchema", null, TypeScriptDependency.SMITHY_TYPES);
         writer.addRelativeImport(
             serviceExceptionName,
             exceptionCtorSymbolName,
@@ -350,7 +352,7 @@ private void writeBaseError() {
 
         String syntheticNamespace = store.var("smithy.ts.sdk.synthetic." + namespace);
         writer.write("""
-                export var $L = error($L, $S, 0, [], [], null);""",
+                export var $L: StaticErrorSchema = [-3, $L, $S, 0, [], []];""",
             serviceExceptionName,
             syntheticNamespace,
             serviceExceptionName
@@ -672,25 +674,19 @@ private String resolveSimpleSchemaNestedContainer(Shape context, Shape shape, Ty
         String staticTypePrefix;
         String sentinel;
         String keySchema = "";
-        String valueSchema;
-        String as;
         switch (shape.getType()) {
             case LIST -> {
                 contained = shape.asListShape().get().getMember();
-                staticTypePrefix = "([1, ";
-                valueSchema = "";
+                staticTypePrefix = "[1, ";
                 sentinel = "64";
                 writer.addImport("StaticListSchema", null, TypeScriptDependency.SMITHY_TYPES);
-                as = " as StaticListSchema)";
             }
             case MAP -> {
                 contained = shape.asMapShape().get().getValue();
-                staticTypePrefix = "([2, ";
+                staticTypePrefix = "[2, ";
                 keySchema = this.resolveSimpleSchema(context, shape.asMapShape().get().getKey()) + ", ";
-                valueSchema = this.resolveSimpleSchema(context, shape.asMapShape().get().getValue()) + ", ";
                 sentinel = "128";
                 writer.addImport("StaticMapSchema", null, TypeScriptDependency.SMITHY_TYPES);
-                as = " as StaticMapSchema)";
             }
             default -> {
                 throw new IllegalArgumentException(
@@ -702,19 +698,12 @@ private String resolveSimpleSchemaNestedContainer(Shape context, Shape shape, Ty
             contained = model.expectShape(contained.asMemberShape().get().getTarget());
         }
 
-        if (contained.isListShape()) {
-            String schemaVarName = checkImportString(context, shape.getId().getName());
-            return staticTypePrefix
-                + checkImportString(context, shape.getId().getNamespace(), "n") + ", " + schemaVarName + ", 0, "
-                + valueSchema
-                + this.resolveSimpleSchema(context, contained) + "]" + as;
-        } else if (contained.isMapShape()) {
+        if (contained.isListShape() || contained.isMapShape()) {
             String schemaVarName = checkImportString(context, shape.getId().getName());
             return staticTypePrefix
                 + checkImportString(context, shape.getId().getNamespace(), "n") + ", " + schemaVarName + ", 0, "
                 + keySchema
-                + valueSchema
-                + this.resolveSimpleSchema(context, contained) + "]" + as;
+                + this.resolveSimpleSchema(context, contained) + "]";
         } else {
             return sentinel + "|" + this.resolveSimpleSchema(context, contained);
         }