@based/functions 1.2.1 → 2.0.0

package/dist/functions.d.ts

@@ -2,10 +2,8 @@ import { Context, HttpSession } from './context';
 import { BasedFunctionClient } from './client';
 import { BasedDataStream } from './stream';
 import { Authorize } from './auth';
-export type ObservableUpdateFunction<K = any> = {
-    (data: K, checksum?: number, diff?: any, fromChecksum?: number, isDeflate?: boolean, rawData?: K, err?: any): void;
-    __internalObs__?: true;
-};
+import { Required } from 'utility-types';
+export type ObservableUpdateFunction<K = any> = (data: K, checksum?: number, err?: any, cache?: Uint8Array, diff?: any, fromChecksum?: number, isDeflate?: boolean) => void;
 export type ObserveErrorListener = (err: any) => void;
 export type HttpHeaders = {
     [header: string]: number | string | (string | number)[];
@@ -30,7 +28,7 @@ export type ChannelMessageFunctionInternal<K = any> = (message: K, err?: any) =>
 export type UninstallFunction = () => Promise<void>;
 type FunctionConfigShared = {
     /** Function name */
-    name: string;
+    name?: string;
     /** In addition to the name, a function can have a custom path for HTTP requests.
      * For example: `path: 'my/custom/path'` will result in the function being
      * available with a request to `env.based.io/my/custom/path`
@@ -50,14 +48,40 @@ type FunctionConfigShared = {
     internalOnly?: boolean;
     /** Can hold extra information about a spec */
     data?: any;
-    /** Unistall after idle, in ms */
+    /** Unistall after idle, in ms -1 indicates endless */
     uninstallAfterIdleTime?: number;
     /** Hook that fires on uninstall of the function e.g. to clean up database connections */
     uninstall?: UninstallFunction;
     /** Specific authorize for this function */
     authorize?: Authorize;
+    /** Relay allows functions to relay traffic to another `@based/server`
+      `Currently not supported for `stream`
+    
+      ```js
+      new BasedServer({
+      clients: { events: BasedClient },
+      functions: {
+        specs:
+          somethingToRelay: {
+            relay: { client: 'events', target: 'hello' },
+            type: 'function'
+          })
+        }
+      }
+      })
+      ```
+    */
+    relay?: {
+        client: string;
+        target?: string;
+    };
+    /** Function version */
+    version?: number;
+    /** Used inernaly to check if a function is ready to uninstall */
+    timeoutCounter?: number;
 };
-export type BasedFunctionConfig = ({
+export type BasedFunctionTypes = 'channel' | 'query' | 'function' | 'stream';
+export type BasedChannelFunctionConfig = {
     /** Function type `channel, function, query, stream, authorize` */
     type: 'channel';
     /** Channel subscriber
@@ -84,32 +108,47 @@ export type BasedFunctionConfig = ({
     publisher?: BasedChannelPublishFunction;
     /** Makes only the publisher public */
     publicPublisher?: boolean;
-    name: string;
     /** How long should the channel subscriber remain active after all subscribers are gone, in ms */
     closeAfterIdleTime?: number;
-} & FunctionConfigShared) | ({
-    /** Function type `channel, function, query, stream, authorize` */
+    /** Only for Publisher */
+    httpResponse?: HttpResponse;
+} & FunctionConfigShared;
+export type BasedCallFunctionConfig = {
+    /** Function type `channel, function, query, stream` */
     type: 'function';
-    function: BasedFunction;
-    name: string;
+    fn: BasedFunction;
     httpResponse?: HttpResponse;
-} & FunctionConfigShared) | ({
-    /** Function type `channel, function, query, stream, authorize` */
+} & FunctionConfigShared;
+export type BasedQueryFunctionConfig = {
+    /** Function type `channel, function, query, stream` */
     type: 'query';
-    function: BasedQueryFunction;
-    name: string;
+    fn: BasedQueryFunction;
     httpResponse?: HttpResponse;
     /** How long should the query function remain active after all subscribers are gone, in ms */
     closeAfterIdleTime?: number;
-} & FunctionConfigShared) | ({
-    /** Function type `channel, function, query, stream, authorize` */
+} & FunctionConfigShared;
+export type BasedStreamFunctionConfig = {
+    /** Function type `channel, function, query, stream` */
     type: 'stream';
-    function: BasedStreamFunction;
-    name: string;
-} & FunctionConfigShared) | {
-    /** Function type `channel, function, query, stream, authorize` */
+    fn: BasedStreamFunction;
+} & FunctionConfigShared;
+export type BasedFunctionConfig<T extends BasedFunctionTypes = BasedFunctionTypes> = T extends 'channel' ? BasedChannelFunctionConfig : T extends 'function' ? BasedCallFunctionConfig : T extends 'query' ? BasedQueryFunctionConfig : T extends 'stream' ? BasedStreamFunctionConfig : BasedChannelFunctionConfig | BasedCallFunctionConfig | BasedQueryFunctionConfig | BasedStreamFunctionConfig;
+export type BasedAuthorizeFunctionConfig = {
+    /** Function type `authorize` */
     type: 'authorize';
     function: Authorize;
-    name: string;
+};
+export type BasedRoute<T extends BasedFunctionTypes = BasedFunctionTypes, R extends keyof BasedFunctionConfig = 'type' | 'name'> = Required<Partial<BasedFunctionConfig<T>>, R>;
+export type BasedFunctionConfigComplete<T extends BasedFunctionTypes = BasedFunctionTypes> = Required<BasedFunctionConfig<T>, 'maxPayloadSize' | 'rateLimitTokens' | 'version' | 'name'>;
+export type BasedRouteComplete<T extends BasedFunctionTypes = BasedFunctionTypes> = Required<Partial<BasedFunctionConfig<T>>, 'type' | 'name' | 'maxPayloadSize' | 'rateLimitTokens'>;
+export declare function isBasedRoute<T extends BasedFunctionTypes>(type: T, route: any): route is BasedRoute<T>;
+export declare function isAnyBasedRoute(route: any): route is BasedRoute;
+export declare function isBasedFunctionConfig<T extends BasedFunctionTypes>(type: T, config: any): config is BasedFunctionConfig<T>;
+export declare function isAnyBasedFunctionConfig(config: any): config is BasedFunctionConfig;
+export type BasedRoutes = {
+    [name: string]: BasedRoute<BasedFunctionTypes, 'type'>;
+};
+export type BasedFunctionConfigs = {
+    [name: string]: BasedFunctionConfig<BasedFunctionTypes>;
 };
 export {};

package/dist/functions.js

@@ -1,3 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnyBasedFunctionConfig = exports.isBasedFunctionConfig = exports.isAnyBasedRoute = exports.isBasedRoute = void 0;
+function isBasedRoute(type, route) {
+    return (route &&
+        typeof route === 'object' &&
+        route.type === type &&
+        typeof route.name === 'string');
+}
+exports.isBasedRoute = isBasedRoute;
+function isAnyBasedRoute(route) {
+    return (route &&
+        typeof route === 'object' &&
+        (route.type === 'channel' ||
+            route.type === 'query' ||
+            route.type === 'function' ||
+            route.type === 'stream') &&
+        typeof route.name === 'string');
+}
+exports.isAnyBasedRoute = isAnyBasedRoute;
+function isBasedFunctionConfig(type, config) {
+    return isBasedRoute(type, config);
+}
+exports.isBasedFunctionConfig = isBasedFunctionConfig;
+function isAnyBasedFunctionConfig(config) {
+    return isAnyBasedRoute(config);
+}
+exports.isAnyBasedFunctionConfig = isAnyBasedFunctionConfig;
 //# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":""}
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":";;;AAwPA,SAAgB,YAAY,CAC1B,IAAO,EACP,KAAU;IAEV,OAAO,CACL,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,CAAC,IAAI,KAAK,IAAI;QACnB,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAC/B,CAAA;AACH,CAAC;AAVD,oCAUC;AAED,SAAgB,eAAe,CAAC,KAAU;IACxC,OAAO,CACL,KAAK;QACL,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS;YACvB,KAAK,CAAC,IAAI,KAAK,OAAO;YACtB,KAAK,CAAC,IAAI,KAAK,UAAU;YACzB,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;QAC1B,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAC/B,CAAA;AACH,CAAC;AAVD,0CAUC;AAED,SAAgB,qBAAqB,CACnC,IAAO,EACP,MAAW;IAEX,OAAO,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;AACnC,CAAC;AALD,sDAKC;AAED,SAAgB,wBAAwB,CACtC,MAAW;IAEX,OAAO,eAAe,CAAC,MAAM,CAAC,CAAA;AAChC,CAAC;AAJD,4DAIC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/functions",
-  "version": "1.2.1",
+  "version": "2.0.0",
   "license": "MIT",
   "main": "dist/index.js",
   "scripts": {
@@ -10,7 +10,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@saulx/utils": "^3.2.1"
+    "utility-types": "^3.10.0",
+    "@saulx/utils": "^3.2.2"
   },
   "devDependencies": {
     "ts-node": "10.9.1",

package/src/functions.ts

@@ -2,22 +2,18 @@ import { Context, HttpSession } from './context'
 import { BasedFunctionClient } from './client'
 import { BasedDataStream } from './stream'
 import { Authorize } from './auth'
+import { Required } from 'utility-types'
 
-export type ObservableUpdateFunction<K = any> = {
-  (
-    data: K,
-    checksum?: number,
-    diff?: any,
-    fromChecksum?: number,
-    isDeflate?: boolean,
-    rawData?: K,
-    // todo fix there errors TODO: make extra package 'errors' for client and server
-    err?: any
-  ): void
-  __internalObs__?: true
-}
+export type ObservableUpdateFunction<K = any> = (
+  data: K,
+  checksum?: number,
+  err?: any,
+  cache?: Uint8Array,
+  diff?: any,
+  fromChecksum?: number,
+  isDeflate?: boolean
+) => void
 
-// TODO: use error package
 export type ObserveErrorListener = (err: any) => void
 
 export type HttpHeaders = {
@@ -99,7 +95,7 @@ export type UninstallFunction = () => Promise<void>
 
 type FunctionConfigShared = {
   /** Function name */
-  name: string
+  name?: string
   /** In addition to the name, a function can have a custom path for HTTP requests.
    * For example: `path: 'my/custom/path'` will result in the function being
    * available with a request to `env.based.io/my/custom/path`
@@ -119,71 +115,178 @@ type FunctionConfigShared = {
   internalOnly?: boolean
   /** Can hold extra information about a spec */
   data?: any
-  /** Unistall after idle, in ms */
+  /** Unistall after idle, in ms -1 indicates endless */
   uninstallAfterIdleTime?: number
   /** Hook that fires on uninstall of the function e.g. to clean up database connections */
   uninstall?: UninstallFunction
   /** Specific authorize for this function */
   authorize?: Authorize
+  /** Relay allows functions to relay traffic to another `@based/server` 
+    `Currently not supported for `stream` 
+  
+    ```js
+    new BasedServer({ 
+    clients: { events: BasedClient },
+    functions: { 
+      specs: 
+        somethingToRelay: { 
+          relay: { client: 'events', target: 'hello' }, 
+          type: 'function' 
+        })
+      }
+    }
+    })
+    ```
+  */
+  relay?: {
+    client: string
+    target?: string
+  }
+  /** Function version */
+  version?: number
+  /** Used inernaly to check if a function is ready to uninstall */
+  timeoutCounter?: number
 }
 
-export type BasedFunctionConfig =
-  | ({
-      /** Function type `channel, function, query, stream, authorize` */
-      type: 'channel'
-      /** Channel subscriber 
-        
-       ```js
-       const subscribe = (based, payload, id, update) => {
-          let cnt = 0
-          const interval = setInterval(() => {
-            update(++cnt)
-          })
-          return () => clearInterval(cnt)
-       }
-       ```
-      */
-      subscriber?: BasedChannelFunction
-      /** Channel publisher 
-        
-       ```js
-       const publisher = (based, payload, msg, id) => {
-          publishToChannel(id, msg)
-       }
-       ```
-      */
-      publisher?: BasedChannelPublishFunction
-      /** Makes only the publisher public */
-      publicPublisher?: boolean
-      name: string
-      /** How long should the channel subscriber remain active after all subscribers are gone, in ms */
-      closeAfterIdleTime?: number
-    } & FunctionConfigShared)
-  | ({
-      /** Function type `channel, function, query, stream, authorize` */
-      type: 'function'
-      function: BasedFunction
-      name: string
-      httpResponse?: HttpResponse
-    } & FunctionConfigShared)
-  | ({
-      /** Function type `channel, function, query, stream, authorize` */
-      type: 'query'
-      function: BasedQueryFunction
-      name: string
-      httpResponse?: HttpResponse
-      /** How long should the query function remain active after all subscribers are gone, in ms */
-      closeAfterIdleTime?: number
-    } & FunctionConfigShared)
-  | ({
-      /** Function type `channel, function, query, stream, authorize` */
-      type: 'stream'
-      function: BasedStreamFunction
-      name: string
-    } & FunctionConfigShared)
-  | {
-      /** Function type `channel, function, query, stream, authorize` */
-      type: 'authorize'
-      function: Authorize
-      name: string
-    }
+export type BasedFunctionTypes = 'channel' | 'query' | 'function' | 'stream'
+
+export type BasedChannelFunctionConfig = {
+  /** Function type `channel, function, query, stream, authorize` */
+  type: 'channel'
+  /** Channel subscriber 
+    
+   ```js
+   const subscribe = (based, payload, id, update) => {
+      let cnt = 0
+      const interval = setInterval(() => {
+        update(++cnt)
+      })
+      return () => clearInterval(cnt)
+   }
+   ```
+  */
+  subscriber?: BasedChannelFunction
+  /** Channel publisher 
+    
+   ```js
+   const publisher = (based, payload, msg, id) => {
+      publishToChannel(id, msg)
+   }
+   ```
+  */
+  publisher?: BasedChannelPublishFunction
+  /** Makes only the publisher public */
+  publicPublisher?: boolean
+  /** How long should the channel subscriber remain active after all subscribers are gone, in ms */
+  closeAfterIdleTime?: number
+  /** Only for Publisher */
+  httpResponse?: HttpResponse
+} & FunctionConfigShared
+
+export type BasedCallFunctionConfig = {
+  /** Function type `channel, function, query, stream` */
+  type: 'function'
+  fn: BasedFunction
+  httpResponse?: HttpResponse
+} & FunctionConfigShared
+
+export type BasedQueryFunctionConfig = {
+  /** Function type `channel, function, query, stream` */
+  type: 'query'
+  fn: BasedQueryFunction
+  httpResponse?: HttpResponse
+  /** How long should the query function remain active after all subscribers are gone, in ms */
+  closeAfterIdleTime?: number
+} & FunctionConfigShared
+
+export type BasedStreamFunctionConfig = {
+  /** Function type `channel, function, query, stream` */
+  type: 'stream'
+  fn: BasedStreamFunction
+} & FunctionConfigShared
+
+export type BasedFunctionConfig<
+  T extends BasedFunctionTypes = BasedFunctionTypes
+> = T extends 'channel'
+  ? BasedChannelFunctionConfig
+  : T extends 'function'
+  ? BasedCallFunctionConfig
+  : T extends 'query'
+  ? BasedQueryFunctionConfig
+  : T extends 'stream'
+  ? BasedStreamFunctionConfig
+  :
+      | BasedChannelFunctionConfig
+      | BasedCallFunctionConfig
+      | BasedQueryFunctionConfig
+      | BasedStreamFunctionConfig
+
+export type BasedAuthorizeFunctionConfig = {
+  /** Function type `authorize` */
+  type: 'authorize'
+  function: Authorize
+}
+
+export type BasedRoute<
+  T extends BasedFunctionTypes = BasedFunctionTypes,
+  R extends keyof BasedFunctionConfig = 'type' | 'name'
+> = Required<Partial<BasedFunctionConfig<T>>, R>
+
+export type BasedFunctionConfigComplete<
+  T extends BasedFunctionTypes = BasedFunctionTypes
+> = Required<
+  BasedFunctionConfig<T>,
+  'maxPayloadSize' | 'rateLimitTokens' | 'version' | 'name'
+>
+
+export type BasedRouteComplete<
+  T extends BasedFunctionTypes = BasedFunctionTypes
+> = Required<
+  Partial<BasedFunctionConfig<T>>,
+  'type' | 'name' | 'maxPayloadSize' | 'rateLimitTokens'
+>
+
+export function isBasedRoute<T extends BasedFunctionTypes>(
+  type: T,
+  route: any
+): route is BasedRoute<T> {
+  return (
+    route &&
+    typeof route === 'object' &&
+    route.type === type &&
+    typeof route.name === 'string'
+  )
+}
+
+export function isAnyBasedRoute(route: any): route is BasedRoute {
+  return (
+    route &&
+    typeof route === 'object' &&
+    (route.type === 'channel' ||
+      route.type === 'query' ||
+      route.type === 'function' ||
+      route.type === 'stream') &&
+    typeof route.name === 'string'
+  )
+}
+
+export function isBasedFunctionConfig<T extends BasedFunctionTypes>(
+  type: T,
+  config: any
+): config is BasedFunctionConfig<T> {
+  return isBasedRoute(type, config)
+}
+
+export function isAnyBasedFunctionConfig(
+  config: any
+): config is BasedFunctionConfig {
+  return isAnyBasedRoute(config)
+}
+
+export type BasedRoutes = {
+  [name: string]: BasedRoute<BasedFunctionTypes, 'type'>
+}
+
+export type BasedFunctionConfigs = {
+  [name: string]: BasedFunctionConfig<BasedFunctionTypes>
+}