npm - @smartlyio/oats-runtime - Versions diffs - 4.4.0 → 4.4.1-alpha.18 - Mend

@smartlyio/oats-runtime 4.4.0 → 4.4.1-alpha.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/dist/client.js +1 -1
package/dist/client.js.map +1 -1
package/dist/make.d.ts +5 -3
package/dist/make.js +65 -7
package/dist/make.js.map +1 -1
package/dist/reflection-type.d.ts +1 -0
package/dist/reflection-type.js.map +1 -1
package/dist/runtime.d.ts +6 -0
package/dist/runtime.js +19 -1
package/dist/runtime.js.map +1 -1
package/dist/serialize.d.ts +1 -0
package/dist/serialize.js +41 -0
package/dist/serialize.js.map +1 -0
package/dist/server.d.ts +9 -1
package/dist/server.js +36 -10
package/dist/server.js.map +1 -1
package/dist/type-tag.d.ts +7 -0
package/dist/type-tag.js +64 -0
package/dist/type-tag.js.map +1 -0
package/jest.config.js +38 -0
package/package.json +2 -2
package/src/client.ts +2 -1
package/src/make.ts +79 -8
package/src/reflection-type.ts +1 -0
package/src/runtime.ts +21 -0
package/src/serialize.ts +36 -0
package/src/server.ts +71 -14
package/src/type-tag.ts +63 -0

package/src/server.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { assert } from './assert';
 import safeNavigation from '@smartlyio/safe-navigation';
 import { Make, MakeOptions, Maker, ValidationError, validationErrorPrinter } from './make';
+import { serialize } from './serialize';
 export type { RedirectStatus } from './redirect';
@@ -128,17 +129,34 @@ function voidify(value: object | undefined | null) {
   return null;
 }
-function cleanHeaders<H>(maker: Maker<any, H>, headers: object) {
-  const normalized = voidify(lowercaseObject(headers));
+function cleanHeaders<H>(mode: Mode, maker: Maker<any, H>, headers: object) {
+  // note: we now expect that on client side headers are type conforming so do not need to lowercase those
+  // this is slightly breaking change is somebody has subverted the type checker
+  const normalized = voidify(mode === 'server' ? lowercaseObject(headers) : headers);
   const acceptsNull = maker(null);
   if (acceptsNull.isSuccess()) {
     return acceptsNull.success();
   }
   return maker(normalized, {
-    unknownField: 'drop'
+    unknownField: 'drop',
+    convertFromNetwork: mode === 'server'
   }).success(throwRequestValidationError.bind(null, 'headers'));
 }
+function serializeWhenClient(mode: Mode, value: any) {
+  if (mode === 'client') {
+    return serialize(value);
+  }
+  return value;
+}
+function getOutBody<Body extends RequestBody<any>>(mode: Mode, value: Body): Body {
+  if (!value) {
+    return value;
+  }
+  return { contentType: value.contentType, value: serializeWhenClient(mode, value.value) } as Body;
+}
 export function safe<
   H extends Headers,
   P extends Params,
@@ -153,7 +171,7 @@ export function safe<
   body: Maker<any, Body>,
   response: Maker<any, R>,
   endpoint: Endpoint<H, P, Q, Body, R, RC>,
-  { validationOptions = {} }: HandlerOptions = {}
+  { validationOptions = {}, mode }: HandlerOptions & InternalHandlerOptions = { mode: 'client' }
 ): Endpoint<
   Headers,
   Params,
@@ -163,24 +181,51 @@ export function safe<
   RequestContext
 > {
   return async ctx => {
+    // note: data coming to client adapter needs to be serialized and data coming from the adapter needs conversion from network
+    // note: data coming to server adapter needs to be deserialized and data coming from the adapter needs serialization
+    // this is all very clear.
+    const internalMakeOptions = { convertFromNetwork: mode === 'server' };
     const result = await endpoint({
       path: ctx.path,
       method: ctx.method,
       servers: ctx.servers,
       op: ctx.op,
-      headers: cleanHeaders(headers, ctx.headers),
-      params: params(voidify(ctx.params), validationOptions.params).success(
-        throwRequestValidationError.bind(null, 'params')
+      headers: serializeWhenClient(mode, cleanHeaders(mode, headers, ctx.headers)),
+      // note: path params come to the adapter in network format always as those are gleaned from the path definition
+      params: params(voidify(ctx.params), {
+        ...validationOptions.params,
+        ...internalMakeOptions,
+        convertFromNetwork: true
+      }).success(throwRequestValidationError.bind(null, 'params')),
+      query: serializeWhenClient(
+        mode,
+        query(ctx.query || {}, { ...validationOptions.query, ...internalMakeOptions }).success(
+          throwRequestValidationError.bind(null, 'query')
+        )
       ),
-      query: query(ctx.query || {}, validationOptions.query).success(
-        throwRequestValidationError.bind(null, 'query')
+      body: getOutBody<Body>(
+        mode,
+        body(voidify(ctx.body), internalMakeOptions).success(
+          throwRequestValidationError.bind(null, 'body')
+        )
       ),
-      body: body(voidify(ctx.body)).success(throwRequestValidationError.bind(null, 'body')),
       requestContext: ctx.requestContext as any
     });
-    return response(result).success(
+    const responseValue = response(result, { convertFromNetwork: mode === 'client' }).success(
       throwResponseValidationError.bind(null, `body ${ctx.path}`, result.value.value)
     );
+    if (mode === 'client' || !responseValue) {
+      return responseValue;
+    }
+    // the response must be serialized for transferring from server to client
+    return {
+      ...responseValue,
+      headers: serialize(responseValue.headers),
+      value: {
+        ...responseValue.value,
+        value: serialize(responseValue.value.value)
+      }
+    };
   };
 }
@@ -202,7 +247,7 @@ interface CheckingTree {
     [method: string]: {
       safeHandler: (
         e: Endpoint<any, any, any, any, any, any>,
-        opts?: HandlerOptions
+        opts?: HandlerOptions & InternalHandlerOptions
       ) => SafeEndpoint;
       op: string;
       servers: string[];
@@ -228,7 +273,10 @@ function createTree(handlers: Handler[]): CheckingTree {
       memo[element.path] = {};
     }
     memo[element.path][element.method] = {
-      safeHandler: (e: Endpoint<any, any, any, any, any, any>, opts?: HandlerOptions) =>
+      safeHandler: (
+        e: Endpoint<any, any, any, any, any, any>,
+        opts?: HandlerOptions & InternalHandlerOptions
+      ) =>
         safe(
           element.headers,
           element.params,
@@ -260,6 +308,15 @@ export type ServerAdapter = (
   servers: string[]
 ) => void;
+type Mode = 'client' | 'server';
+export interface InternalHandlerOptions {
+  /** whether we are calling this on client side or in server side.
+   * This may have effect on eg network <-> ts property mapping.
+   * This value is set automatically by oats.
+   * */
+  mode: Mode;
+}
 export interface HandlerOptions {
   /**
    * Options for request schema validation.
@@ -287,7 +344,7 @@ export function createHandlerFactory<Spec>(
             path,
             endpointWrapper.op,
             assertMethod(method),
-            endpointWrapper.safeHandler(methodHandler, opts),
+            endpointWrapper.safeHandler(methodHandler, { ...opts, mode: 'server' }),
             endpointWrapper.servers
           );
         });

package/src/type-tag.ts ADDED Viewed

@@ -0,0 +1,63 @@
+import { Type } from './reflection-type';
+import { ValueClass } from './value-class';
+export function withType<A>(to: A, type: Type[]): A {
+  if (type.length === 0) {
+    return to;
+  }
+  // todo: is it possible to confuse typing by re-use of valueclassed values
+  //  eg. with value 'v: SomeValueClass' passing it to multiple makers
+  // -> no? the re-use happens only if the valueclass instance matches so it
+  // will not mutate the tagged reflection types
+  const previous = getTypeSet(to);
+  if (previous) {
+    type.forEach(type => previous.add(type));
+    return to;
+  }
+  const newType = new Set(type);
+  // tag each constructed object with a hidden type property
+  Object.defineProperty(to, reflection, {
+    enumerable: false,
+    value: newType
+  });
+  return to;
+}
+export function getTypeSet(value: Record<string, any>): Set<Type> | undefined {
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+  // NOTE: prefer using the added reflection type instead of the contstructor type
+  // the added reflection type will have types from eg allOf
+  // @ts-ignore
+  const t: Set<Type> = value[reflection];
+  if (t && t.size > 0) {
+    return t;
+  }
+  if (value instanceof ValueClass) {
+    // a bit of leap here to trust that all ValueClasses have generated `reflection`
+    // @ts-ignore
+    const classType = new Set([value.constructor.reflection().definition]);
+    // tag each constructed object with a hidden type property
+    // this ensures that ValueClasses have a mutable reflection type property
+    Object.defineProperty(value, reflection, {
+      enumerable: false,
+      value: classType
+    });
+    return classType;
+  }
+  return;
+}
+/**  Get reflection type from a  made value for serialization.
+ * Note that only directly made object values or ValueClasses can be used
+ * */
+export function getType(value: Record<string, any>): Type[] | undefined {
+  const t = getTypeSet(value);
+  if (t) {
+    return [...t];
+  }
+}
+const reflection = Symbol('reflection');