feat(core/schema): add schema classes

Author: kuhe

.changeset/grumpy-cobras-melt.md

@@ -0,0 +1,6 @@
+---
+"@smithy/core": minor
+"@smithy/middleware-serde": patch
+---
+
+add schema classes

packages/core/package.json

@@ -11,8 +11,8 @@
     "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo || exit 0",
     "lint": "npx eslint -c ../../.eslintrc.js \"src/**/*.ts\" --fix && node ./scripts/lint",
     "format": "prettier --config ../../prettier.config.js --ignore-path ../../.prettierignore --write \"**/*.{ts,md,json}\"",
-    "test": "yarn g:vitest run",
     "test:cbor:perf": "node ./scripts/cbor-perf.mjs",
+    "test": "yarn g:vitest run",
     "test:watch": "yarn g:vitest watch"
   },
   "main": "./dist-cjs/index.js",
@@ -52,6 +52,13 @@
       "import": "./dist-es/submodules/serde/index.js",
       "require": "./dist-cjs/submodules/serde/index.js",
       "types": "./dist-types/submodules/serde/index.d.ts"
+    },
+    "./schema": {
+      "module": "./dist-es/submodules/schema/index.js",
+      "node": "./dist-cjs/submodules/schema/index.js",
+      "import": "./dist-es/submodules/schema/index.js",
+      "require": "./dist-cjs/submodules/schema/index.js",
+      "types": "./dist-types/submodules/schema/index.d.ts"
     }
   },
   "author": {
@@ -85,6 +92,8 @@
     "./cbor.js",
     "./protocols.d.ts",
     "./protocols.js",
+    "./schema.d.ts",
+    "./schema.js",
     "./serde.d.ts",
     "./serde.js",
     "dist-*/**"

packages/core/schema.d.ts

@@ -0,0 +1,8 @@
+
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+declare module "@smithy/core/schema" {
+  export * from "@smithy/core/dist-types/submodules/schema/index.d";
+}

packages/core/schema.js

@@ -0,0 +1,6 @@
+
+/**
+ * Do not edit:
+ * This is a compatibility redirect for contexts that do not understand package.json exports field.
+ */
+module.exports = require("./dist-cjs/submodules/schema/index.js");

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

@@ -0,0 +1,76 @@
+import type { Schema as ISchema } from "@smithy/types";
+
+import { ErrorSchema } from "./schemas/ErrorSchema";
+
+export class TypeRegistry {
+  public static active: TypeRegistry | null = null;
+  public static readonly registries = new Map<string, TypeRegistry>();
+
+  private constructor(
+    public readonly namespace: string,
+    private schemas: Map<string, ISchema> = new Map()
+  ) {}
+
+  /**
+   * @param namespace - specifier.
+   * @returns the schema for that namespace, creating it if necessary.
+   */
+  public static for(namespace: string): TypeRegistry {
+    if (!TypeRegistry.registries.has(namespace)) {
+      TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+    }
+    return TypeRegistry.registries.get(namespace)!;
+  }
+
+  /**
+   * The active type registry's namespace is used.
+   * @param shapeId - to be registered.
+   * @param schema - to be registered.
+   */
+  public register(shapeId: string, schema: ISchema) {
+    const qualifiedName = this.normalizeShapeId(shapeId);
+    const registry = TypeRegistry.for(this.getNamespace(shapeId));
+    registry.schemas.set(qualifiedName, schema);
+  }
+
+  /**
+   * @param shapeId - query.
+   * @returns the schema.
+   */
+  public getSchema(shapeId: string): ISchema {
+    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(id)!;
+  }
+
+  public getBaseException(): ErrorSchema | undefined {
+    for (const [id, schema] of this.schemas.entries()) {
+      if (id.startsWith("awssdkjs.synthetic.") && id.endsWith("ServiceException")) {
+        return schema as ErrorSchema;
+      }
+    }
+    return undefined;
+  }
+
+  public find(seeker: (schema: ISchema) => boolean) {
+    return [...this.schemas.values()].find(seeker);
+  }
+
+  public destroy() {
+    TypeRegistry.registries.delete(this.namespace);
+    this.schemas.clear();
+  }
+
+  private normalizeShapeId(shapeId: string) {
+    if (shapeId.includes("#")) {
+      return shapeId;
+    }
+    return this.namespace + "#" + shapeId;
+  }
+
+  private getNamespace(shapeId: string) {
+    return this.normalizeShapeId(shapeId).split("#")[0];
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { Schema, SchemaRef } from "@smithy/types";
+
+/**
+ * Dereferences a SchemaRef if needed.
+ * @internal
+ */
+export const deref = (schemaRef: SchemaRef): Schema => {
+  if (typeof schemaRef === "function") {
+    return schemaRef();
+  }
+  return schemaRef;
+};

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

@@ -0,0 +1,12 @@
+export * from "./deref";
+export * from "./middleware/getSchemaSerdePlugin";
+export * from "./schemas/ListSchema";
+export * from "./schemas/MapSchema";
+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 "./schemas/sentinels";
+export * from "./TypeRegistry";

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

@@ -0,0 +1,49 @@
+import {
+  DeserializeHandlerOptions,
+  MetadataBearer,
+  MiddlewareStack,
+  Pluggable,
+  SerdeFunctions,
+  SerializeHandlerOptions,
+} from "@smithy/types";
+
+import { PreviouslyResolved } from "./schema-middleware-types";
+import { schemaDeserializationMiddleware } from "./schemaDeserializationMiddleware";
+import { schemaSerializationMiddleware } from "./schemaSerializationMiddleware";
+
+/**
+ * @internal
+ */
+export const deserializerMiddlewareOption: DeserializeHandlerOptions = {
+  name: "deserializerMiddleware",
+  step: "deserialize",
+  tags: ["DESERIALIZER"],
+  override: true,
+};
+
+/**
+ * @internal
+ */
+export const serializerMiddlewareOption: SerializeHandlerOptions = {
+  name: "serializerMiddleware",
+  step: "serialize",
+  tags: ["SERIALIZER"],
+  override: true,
+};
+
+/**
+ * @internal
+ */
+export function getSchemaSerdePlugin<InputType extends object = any, OutputType extends MetadataBearer = any>(
+  config: PreviouslyResolved
+): Pluggable<InputType, OutputType> {
+  return {
+    applyToStack: (commandStack: MiddlewareStack<InputType, OutputType>) => {
+      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+      // `config` is fully resolved at the point of applying plugins.
+      // As such, config qualifies as SerdeContext.
+      config.protocol.setSerdeContext(config as SerdeFunctions);
+    },
+  };
+}

packages/core/src/submodules/schema/middleware/schema-middleware-types.ts

@@ -0,0 +1,12 @@
+import type { ClientProtocol, SerdeContext, UrlParser } from "@smithy/types";
+
+/**
+ * @internal
+ */
+export type PreviouslyResolved = Omit<
+  SerdeContext & {
+    urlParser: UrlParser;
+    protocol: ClientProtocol<any, any>;
+  },
+  "endpoint"
+>;