@based/functions 1.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @based/cloud-function@1.0.0 build
+> npx  tsc
+

package/dist/auth.d.ts

@@ -0,0 +1,15 @@
+import { BasedFunctionClient } from './client';
+import { HttpRequest } from './uws';
+import { Context, WebSocketSession, HttpSession } from './context';
+export declare type AuthState = {
+    token?: string;
+    userId?: string;
+    refreshToken?: string;
+    error?: string;
+    persistent?: boolean;
+    type?: string;
+};
+export declare type Authorize = (based: BasedFunctionClient, context: Context<HttpSession | WebSocketSession>, name: string, // name as generic dope
+payload?: any) => Promise<boolean>;
+export declare type VerifyAuthState = (based: BasedFunctionClient, context: Context<HttpSession | WebSocketSession>, authState: AuthState) => true | AuthState;
+export declare type AuthorizeConnection = (based: BasedFunctionClient, req: HttpRequest) => Promise<boolean>;

package/dist/auth.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=auth.js.map

package/dist/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":""}

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import { AuthState } from './auth';
+import { Context } from './context';
+import { BasedQuery } from './query';
+export declare abstract class BasedFunctionClient {
+    server: any;
+    abstract call(name: string, payload?: any, ctx?: Context): Promise<any>;
+    abstract query(name: string, payload?: any): BasedQuery;
+    abstract stream(name: string, stream?: any, ctx?: Context): Promise<any>;
+    abstract sendAuthState(ctx: Context, authState: AuthState): void;
+    abstract renewAuthState(ctx: Context): void;
+}

package/dist/client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasedFunctionClient = void 0;
+class BasedFunctionClient {
+}
+exports.BasedFunctionClient = BasedFunctionClient;
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":";;;AAIA,MAAsB,mBAAmB;CAYxC;AAZD,kDAYC"}

package/dist/context.d.ts

@@ -0,0 +1,63 @@
+import { AuthState } from './auth';
+import { WebSocket, HttpRequest, HttpResponse } from './uws';
+import { parseQuery } from '@saulx/utils';
+import { BasedFunctionClient } from './client';
+export declare type WebSocketSession = {
+    state?: any;
+    query: string;
+    ua: string;
+    ip: string;
+    id: number;
+    method: string;
+    authState: AuthState;
+    obs: Set<number>;
+    unauthorizedObs: Set<{
+        id: number;
+        checksum: number;
+        name: string;
+        payload: any;
+    }>;
+    c?: Context<WebSocketSession>;
+} & WebSocket;
+export declare type HttpSession = {
+    state?: any;
+    res: HttpResponse;
+    req: HttpRequest;
+    query?: string;
+    parsedQuery?: ReturnType<typeof parseQuery>;
+    ua: string;
+    ip: string;
+    id: number;
+    authState: AuthState;
+    method: string;
+    corsSend?: boolean;
+    headers: {
+        'content-length'?: number;
+        'content-type'?: string;
+        'content-encoding'?: string;
+        encoding?: string;
+    } & {
+        [key: string]: string;
+    };
+};
+export declare type InternalSessionObservable = {
+    id: number;
+    name: string;
+    type: 'observable';
+};
+export declare type InternalSessionClient = {
+    client: BasedFunctionClient;
+    type: 'client';
+};
+export declare type InternalSession = InternalSessionClient | InternalSessionObservable;
+export declare type MinimalExternalSession = {
+    ua: string;
+    ip: string;
+};
+export declare type Session = WebSocketSession | HttpSession | InternalSession | MinimalExternalSession;
+export declare type Context<S extends Session = Session> = {
+    session?: S;
+};
+export declare const isHttpContext: (ctx: Context<Session>) => ctx is Context<HttpSession>;
+export declare const isWsContext: (ctx: Context<Session>) => ctx is Context<WebSocketSession>;
+export declare const isWsSession: (session: Session) => session is WebSocketSession;

package/dist/context.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWsSession = exports.isWsContext = exports.isHttpContext = void 0;
+const isHttpContext = (ctx) => {
+    if ('res' in ctx?.session) {
+        return true;
+    }
+    return false;
+};
+exports.isHttpContext = isHttpContext;
+const isWsContext = (ctx) => {
+    if (ctx.session && (0, exports.isWsSession)(ctx.session)) {
+        return true;
+    }
+    return false;
+};
+exports.isWsContext = isWsContext;
+const isWsSession = (session) => {
+    if (!('res' in session) && 'ip' in session && 'id' in session) {
+        return true;
+    }
+    return false;
+};
+exports.isWsSession = isWsSession;
+//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":";;;AA4EO,MAAM,aAAa,GAAG,CAC3B,GAAqB,EACQ,EAAE;IAC/B,IAAI,KAAK,IAAI,GAAG,EAAE,OAAO,EAAE;QACzB,OAAO,IAAI,CAAA;KACZ;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAPY,QAAA,aAAa,iBAOzB;AAEM,MAAM,WAAW,GAAG,CACzB,GAAqB,EACa,EAAE;IACpC,IAAI,GAAG,CAAC,OAAO,IAAI,IAAA,mBAAW,EAAC,GAAG,CAAC,OAAO,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAA;KACZ;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAPY,QAAA,WAAW,eAOvB;AAEM,MAAM,WAAW,GAAG,CAAC,OAAgB,EAA+B,EAAE;IAC3E,IAAI,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,EAAE;QAC7D,OAAO,IAAI,CAAA;KACZ;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AALY,QAAA,WAAW,eAKvB"}

package/dist/errors.js

@@ -0,0 +1,2 @@
+// add all errors here and use it in the client as well
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,uDAAuD"}

package/dist/functions.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { Context, HttpSession } from './context';
+import { BasedFunctionClient } from './client';
+import { Stream } from 'stream';
+export declare type ObservableUpdateFunction<K = any> = {
+    (data: K, checksum?: number, diff?: any, fromChecksum?: number, isDeflate?: boolean, rawData?: K, err?: any): void;
+    __internalObs__?: true;
+};
+export declare type ObserveErrorListener = (err: any) => void;
+export declare type CustomHttpResponse = (result: any, payload: any, client: Context<HttpSession>) => Promise<boolean>;
+export declare type BasedFunction<P = any, K = any> = (based: BasedFunctionClient, payload: P, ctx: Context) => Promise<K>;
+export declare type StreamPayload<P = any> = {
+    payload?: P;
+    mimeType: string;
+    size: number;
+    stream: Stream & {
+        size: number;
+        receivedBytes: number;
+    };
+    fileName?: string;
+    extension?: string;
+};
+export declare type BasedStreamFunction<P = any, K = any> = BasedFunction<StreamPayload<P>, K>;
+export declare type BasedQueryFunction<P = any, K = any> = ((based: BasedFunctionClient, payload: P, update: ObservableUpdateFunction<K>) => Promise<() => void>) | ((based: BasedFunctionClient, payload: P, update: ObservableUpdateFunction<K>) => () => void);

package/dist/functions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=functions.js.map

package/dist/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.js","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './context';
+export * from './auth';
+export * from './client';
+export * from './functions';
+export * from './query';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./functions"), exports);
+__exportStar(require("./query"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAAyB;AACzB,yCAAsB;AACtB,2CAAwB;AACxB,8CAA2B;AAC3B,0CAAuB"}

package/dist/network.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=network.js.map

package/dist/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":""}

package/dist/query.d.ts

@@ -0,0 +1,6 @@
+import { ObservableUpdateFunction, ObserveErrorListener } from './functions';
+export declare abstract class BasedQuery {
+    abstract subscribe(onData: ObservableUpdateFunction, onError?: ObserveErrorListener): () => void;
+    abstract getWhen(condition: (data: any, checksum: number) => boolean): Promise<any>;
+    abstract get(): Promise<any>;
+}

package/dist/query.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasedQuery = void 0;
+class BasedQuery {
+}
+exports.BasedQuery = BasedQuery;
+//# sourceMappingURL=query.js.map

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":";;;AAEA,MAAsB,UAAU;CAW/B;AAXD,gCAWC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+// function types
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,iBAAiB"}

package/dist/uws.d.ts

@@ -0,0 +1,141 @@
+export declare type RecognizedString = string | ArrayBuffer | Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+/** A WebSocket connection that is valid from open to close event.
+ * Read more about this in the user manual.
+ */
+export interface WebSocket {
+    /** Sends a message. Make sure to check getBufferedAmount() before sending. Returns true for success, false for built up backpressure that will drain when time is given.
+     * Returning false does not mean nothing was sent, it only means backpressure was built up. This you can check by calling getBufferedAmount() afterwards.
+     *
+     * Make sure you properly understand the concept of backpressure. Check the backpressure example file.
+     */
+    send(message: RecognizedString, isBinary?: boolean, compress?: boolean): boolean;
+    /** Returns the bytes buffered in backpressure. This is similar to the bufferedAmount property in the browser counterpart.
+     * Check backpressure example.
+     */
+    getBufferedAmount(): number;
+    /** Gracefully closes this WebSocket. Immediately calls the close handler.
+     * A WebSocket close message is sent with code and shortMessage.
+     */
+    end(code?: number, shortMessage?: RecognizedString): void;
+    /** Forcefully closes this WebSocket. Immediately calls the close handler.
+     * No WebSocket close message is sent.
+     */
+    close(): void;
+    /** Sends a ping control message. Returns true on success in similar ways as WebSocket.send does (regarding backpressure). This helper function correlates to WebSocket::send(message, uWS::OpCode::PING, ...) in C++. */
+    ping(message?: RecognizedString): boolean;
+    /** Subscribe to a topic. */
+    subscribe(topic: RecognizedString): boolean;
+    /** Unsubscribe from a topic. Returns true on success, if the WebSocket was subscribed. */
+    unsubscribe(topic: RecognizedString): boolean;
+    /** Returns whether this websocket is subscribed to topic. */
+    isSubscribed(topic: RecognizedString): boolean;
+    /** Returns a list of topics this websocket is subscribed to. */
+    getTopics(): string[];
+    /** Publish a message under topic. Backpressure is managed according to maxBackpressure, closeOnBackpressureLimit settings.
+     * Order is guaranteed since v20.
+     */
+    publish(topic: RecognizedString, message: RecognizedString, isBinary?: boolean, compress?: boolean): boolean;
+    /** See HttpResponse.cork. Takes a function in which the socket is corked (packing many sends into one single syscall/SSL block) */
+    cork(cb: () => void): WebSocket;
+    /** Returns the remote IP address. Note that the returned IP is binary, not text.
+     *
+     * IPv4 is 4 byte long and can be converted to text by printing every byte as a digit between 0 and 255.
+     * IPv6 is 16 byte long and can be converted to text in similar ways, but you typically print digits in HEX.
+     *
+     * See getRemoteAddressAsText() for a text version.
+     */
+    getRemoteAddress(): ArrayBuffer;
+    /** Returns the remote IP address as text. See RecognizedString. */
+    getRemoteAddressAsText(): ArrayBuffer;
+    /** Arbitrary user data may be attached to this object. In C++ this is done by using getUserData(). */
+    [key: string]: any;
+}
+/** An HttpResponse is valid until either onAborted callback or any of the .end/.tryEnd calls succeed. You may attach user data to this object. */
+export interface HttpResponse {
+    /** Writes the HTTP status message such as "200 OK".
+     * This has to be called first in any response, otherwise
+     * it will be called automatically with "200 OK".
+     *
+     * If you want to send custom headers in a WebSocket
+     * upgrade response, you have to call writeStatus with
+     * "101 Switching Protocols" before you call writeHeader,
+     * otherwise your first call to writeHeader will call
+     * writeStatus with "200 OK" and the upgrade will fail.
+     *
+     * As you can imagine, we format outgoing responses in a linear
+     * buffer, not in a hash table. You can read about this in
+     * the user manual under "corking".
+     */
+    writeStatus(status: RecognizedString): HttpResponse;
+    /** Writes key and value to HTTP response.
+     * See writeStatus and corking.
+     */
+    writeHeader(key: RecognizedString, value: RecognizedString): HttpResponse;
+    /** Enters or continues chunked encoding mode. Writes part of the response. End with zero length write. Returns true if no backpressure was added. */
+    write(chunk: RecognizedString): boolean;
+    /** Ends this response by copying the contents of body. */
+    end(body?: RecognizedString, closeConnection?: boolean): HttpResponse;
+    /** Ends this response, or tries to, by streaming appropriately sized chunks of body. Use in conjunction with onWritable. Returns tuple [ok, hasResponded]. */
+    tryEnd(fullBodyOrChunk: RecognizedString, totalSize: number): [boolean, boolean];
+    /** Immediately force closes the connection. Any onAborted callback will run. */
+    close(): HttpResponse;
+    /** Returns the global byte write offset for this response. Use with onWritable. */
+    getWriteOffset(): number;
+    /** Registers a handler for writable events. Continue failed write attempts in here.
+     * You MUST return true for success, false for failure.
+     * Writing nothing is always success, so by default you must return true.
+     */
+    onWritable(handler: (offset: number) => boolean): HttpResponse;
+    /** Every HttpResponse MUST have an attached abort handler IF you do not respond
+     * to it immediately inside of the callback. Returning from an Http request handler
+     * without attaching (by calling onAborted) an abort handler is ill-use and will termiante.
+     * When this event emits, the response has been aborted and may not be used. */
+    onAborted(handler: () => void): HttpResponse;
+    /** Handler for reading data from POST and such requests. You MUST copy the data of chunk if isLast is not true. We Neuter ArrayBuffers on return, making it zero length. */
+    onData(handler: (chunk: ArrayBuffer, isLast: boolean) => void): HttpResponse;
+    /** Returns the remote IP address in binary format (4 or 16 bytes). */
+    getRemoteAddress(): ArrayBuffer;
+    /** Returns the remote IP address as text. */
+    getRemoteAddressAsText(): ArrayBuffer;
+    /** Returns the remote IP address in binary format (4 or 16 bytes), as reported by the PROXY Protocol v2 compatible proxy. */
+    getProxiedRemoteAddress(): ArrayBuffer;
+    /** Returns the remote IP address as text, as reported by the PROXY Protocol v2 compatible proxy. */
+    getProxiedRemoteAddressAsText(): ArrayBuffer;
+    /** Corking a response is a performance improvement in both CPU and network, as you ready the IO system for writing multiple chunks at once.
+     * By default, you're corked in the immediately executing top portion of the route handler. In all other cases, such as when returning from
+     * await, or when being called back from an async database request or anything that isn't directly executing in the route handler, you'll want
+     * to cork before calling writeStatus, writeHeader or just write. Corking takes a callback in which you execute the writeHeader, writeStatus and
+     * such calls, in one atomic IO operation. This is important, not only for TCP but definitely for TLS where each write would otherwise result
+     * in one TLS block being sent off, each with one send syscall.
+     *
+     * Example usage:
+     *
+     * res.cork(() => {
+     *   res.writeStatus("200 OK").writeHeader("Some", "Value").write("Hello world!");
+     * });
+     */
+    cork(cb: () => void): HttpResponse;
+    /** Upgrades a HttpResponse to a WebSocket. See UpgradeAsync, UpgradeSync example files. */
+    upgrade<T>(userData: T, secWebSocketKey: RecognizedString, secWebSocketProtocol: RecognizedString, secWebSocketExtensions: RecognizedString, context: any): void;
+    /** Arbitrary user data may be attached to this object */
+    [key: string]: any;
+}
+/** An HttpRequest is stack allocated and only accessible during the callback invocation. */
+export interface HttpRequest {
+    /** Returns the lowercased header value or empty string. */
+    getHeader(lowerCaseKey: RecognizedString): string;
+    /** Returns the parsed parameter at index. Corresponds to route. */
+    getParameter(index: number): string;
+    /** Returns the URL including initial /slash */
+    getUrl(): string;
+    /** Returns the HTTP method, useful for "any" routes. */
+    getMethod(): string;
+    /** Returns the raw querystring (the part of URL after ? sign) or empty string. */
+    getQuery(): string;
+    /** Returns a decoded query parameter value or empty string. */
+    getQuery(key: string): string;
+    /** Loops over all headers. */
+    forEach(cb: (key: string, value: string) => void): void;
+    /** Setting yield to true is to say that this route handler did not handle the route, causing the router to continue looking for a matching route handler, or fail. */
+    setYield(y: boolean): HttpRequest;
+}

package/dist/uws.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=uws.js.map

package/dist/uws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uws.js","sourceRoot":"","sources":["../src/uws.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@based/functions",
+  "version": "1.0.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "npx  tsc",
+    "watch": "npm run build -- --watch",
+    "clean": "rimraf {.turbo,dist,node_modules}"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@saulx/utils": "^3.2.0"
+  },
+  "devDependencies": {
+    "ts-node": "10.9.1",
+    "typescript": "^4.3.5",
+    "rimraf": "^3.0.2"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,33 @@
+import { BasedFunctionClient } from './client'
+import { HttpRequest } from './uws'
+import { Context, WebSocketSession, HttpSession } from './context'
+
+export type AuthState = {
+  token?: string
+  userId?: string
+  refreshToken?: string
+  error?: string
+  persistent?: boolean
+  type?: string
+}
+
+export type Authorize = (
+  based: BasedFunctionClient,
+  context: Context<HttpSession | WebSocketSession>,
+  name: string, // name as generic dope
+  payload?: any
+) => Promise<boolean>
+
+// True - its the same all good
+// AuthState - new auth state send it
+//    if error send error state (and reject)
+export type VerifyAuthState = (
+  based: BasedFunctionClient,
+  context: Context<HttpSession | WebSocketSession>,
+  authState: AuthState
+) => true | AuthState
+
+export type AuthorizeConnection = (
+  based: BasedFunctionClient,
+  req: HttpRequest
+) => Promise<boolean>

package/src/client.ts

@@ -0,0 +1,17 @@
+import { AuthState } from './auth'
+import { Context } from './context'
+import { BasedQuery } from './query'
+
+export abstract class BasedFunctionClient {
+  server: any
+
+  abstract call(name: string, payload?: any, ctx?: Context): Promise<any>
+
+  abstract query(name: string, payload?: any): BasedQuery
+
+  abstract stream(name: string, stream?: any, ctx?: Context): Promise<any>
+
+  abstract sendAuthState(ctx: Context, authState: AuthState): void
+
+  abstract renewAuthState(ctx: Context): void
+}

package/src/context.ts

@@ -0,0 +1,100 @@
+import { AuthState } from './auth'
+import { WebSocket, HttpRequest, HttpResponse } from './uws'
+import { parseQuery } from '@saulx/utils'
+import { BasedFunctionClient } from './client'
+
+export type WebSocketSession = {
+  // State can be used for anyting - for us the based class instance
+  state?: any
+  query: string
+  ua: string
+  ip: string
+  id: number // client-id
+  method: string
+  authState: AuthState
+  obs: Set<number>
+  unauthorizedObs: Set<{
+    id: number
+    checksum: number
+    name: string
+    payload: any
+  }>
+  // Optimization so we dont need to keep track of websockets outside of uws
+  c?: Context<WebSocketSession>
+} & WebSocket
+
+export type HttpSession = {
+  // State can be used for anyting - for us the based class instance
+  state?: any
+  res: HttpResponse
+  req: HttpRequest
+  query?: string
+  parsedQuery?: ReturnType<typeof parseQuery>
+  ua: string
+  ip: string
+  id: number // client-id
+  authState: AuthState
+  method: string
+  corsSend?: boolean
+  headers: {
+    'content-length'?: number
+    'content-type'?: string
+    'content-encoding'?: string
+    encoding?: string
+  } & { [key: string]: string }
+}
+
+export type InternalSessionObservable = {
+  id: number
+  name: string
+  type: 'observable'
+}
+
+export type InternalSessionClient = {
+  client: BasedFunctionClient
+  type: 'client'
+}
+
+// Internal session for internal functions
+export type InternalSession = InternalSessionClient | InternalSessionObservable
+
+// used for minimal security errors (e.g. rate limit)
+export type MinimalExternalSession = {
+  ua: string
+  ip: string
+}
+
+export type Session =
+  | WebSocketSession
+  | HttpSession
+  | InternalSession
+  | MinimalExternalSession
+
+export type Context<S extends Session = Session> = {
+  session?: S
+}
+
+export const isHttpContext = (
+  ctx: Context<Session>
+): ctx is Context<HttpSession> => {
+  if ('res' in ctx?.session) {
+    return true
+  }
+  return false
+}
+
+export const isWsContext = (
+  ctx: Context<Session>
+): ctx is Context<WebSocketSession> => {
+  if (ctx.session && isWsSession(ctx.session)) {
+    return true
+  }
+  return false
+}
+
+export const isWsSession = (session: Session): session is WebSocketSession => {
+  if (!('res' in session) && 'ip' in session && 'id' in session) {
+    return true
+  }
+  return false
+}

package/src/functions.ts

@@ -0,0 +1,61 @@
+import { Context, HttpSession } from './context'
+import { BasedFunctionClient } from './client'
+import { Stream } from 'stream'
+
+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
+}
+
+// TODO: use error package
+export type ObserveErrorListener = (err: any) => void
+
+export type CustomHttpResponse = (
+  result: any,
+  payload: any,
+  client: Context<HttpSession>
+) => Promise<boolean>
+
+export type BasedFunction<P = any, K = any> = (
+  based: BasedFunctionClient,
+  payload: P,
+  ctx: Context
+) => Promise<K>
+
+export type StreamPayload<P = any> = {
+  payload?: P
+  mimeType: string
+  size: number
+  stream: Stream & {
+    size: number
+    receivedBytes: number
+  }
+  fileName?: string
+  extension?: string
+}
+
+export type BasedStreamFunction<P = any, K = any> = BasedFunction<
+  StreamPayload<P>,
+  K
+>
+
+export type BasedQueryFunction<P = any, K = any> =
+  | ((
+      based: BasedFunctionClient,
+      payload: P,
+      update: ObservableUpdateFunction<K>
+    ) => Promise<() => void>)
+  | ((
+      based: BasedFunctionClient,
+      payload: P,
+      update: ObservableUpdateFunction<K>
+    ) => () => void)

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './context'
+export * from './auth'
+export * from './client'
+export * from './functions'
+export * from './query'

package/src/query.ts

@@ -0,0 +1,14 @@
+import { ObservableUpdateFunction, ObserveErrorListener } from './functions'
+
+export abstract class BasedQuery {
+  abstract subscribe(
+    onData: ObservableUpdateFunction,
+    onError?: ObserveErrorListener
+  ): () => void
+
+  abstract getWhen(
+    condition: (data: any, checksum: number) => boolean
+  ): Promise<any>
+
+  abstract get(): Promise<any>
+}

package/src/uws.ts

@@ -0,0 +1,197 @@
+export type RecognizedString =
+  | string
+  | ArrayBuffer
+  | Uint8Array
+  | Int8Array
+  | Uint16Array
+  | Int16Array
+  | Uint32Array
+  | Int32Array
+  | Float32Array
+  | Float64Array
+
+/** A WebSocket connection that is valid from open to close event.
+ * Read more about this in the user manual.
+ */
+export interface WebSocket {
+  /** Sends a message. Make sure to check getBufferedAmount() before sending. Returns true for success, false for built up backpressure that will drain when time is given.
+   * Returning false does not mean nothing was sent, it only means backpressure was built up. This you can check by calling getBufferedAmount() afterwards.
+   *
+   * Make sure you properly understand the concept of backpressure. Check the backpressure example file.
+   */
+  send(
+    message: RecognizedString,
+    isBinary?: boolean,
+    compress?: boolean
+  ): boolean
+
+  /** Returns the bytes buffered in backpressure. This is similar to the bufferedAmount property in the browser counterpart.
+   * Check backpressure example.
+   */
+  getBufferedAmount(): number
+
+  /** Gracefully closes this WebSocket. Immediately calls the close handler.
+   * A WebSocket close message is sent with code and shortMessage.
+   */
+  end(code?: number, shortMessage?: RecognizedString): void
+
+  /** Forcefully closes this WebSocket. Immediately calls the close handler.
+   * No WebSocket close message is sent.
+   */
+  close(): void
+
+  /** Sends a ping control message. Returns true on success in similar ways as WebSocket.send does (regarding backpressure). This helper function correlates to WebSocket::send(message, uWS::OpCode::PING, ...) in C++. */
+  ping(message?: RecognizedString): boolean
+
+  /** Subscribe to a topic. */
+  subscribe(topic: RecognizedString): boolean
+
+  /** Unsubscribe from a topic. Returns true on success, if the WebSocket was subscribed. */
+  unsubscribe(topic: RecognizedString): boolean
+
+  /** Returns whether this websocket is subscribed to topic. */
+  isSubscribed(topic: RecognizedString): boolean
+
+  /** Returns a list of topics this websocket is subscribed to. */
+  getTopics(): string[]
+
+  /** Publish a message under topic. Backpressure is managed according to maxBackpressure, closeOnBackpressureLimit settings.
+   * Order is guaranteed since v20.
+   */
+  publish(
+    topic: RecognizedString,
+    message: RecognizedString,
+    isBinary?: boolean,
+    compress?: boolean
+  ): boolean
+
+  /** See HttpResponse.cork. Takes a function in which the socket is corked (packing many sends into one single syscall/SSL block) */
+  cork(cb: () => void): WebSocket
+
+  /** Returns the remote IP address. Note that the returned IP is binary, not text.
+   *
+   * IPv4 is 4 byte long and can be converted to text by printing every byte as a digit between 0 and 255.
+   * IPv6 is 16 byte long and can be converted to text in similar ways, but you typically print digits in HEX.
+   *
+   * See getRemoteAddressAsText() for a text version.
+   */
+  getRemoteAddress(): ArrayBuffer
+
+  /** Returns the remote IP address as text. See RecognizedString. */
+  getRemoteAddressAsText(): ArrayBuffer
+
+  /** Arbitrary user data may be attached to this object. In C++ this is done by using getUserData(). */
+  [key: string]: any
+}
+
+/** An HttpResponse is valid until either onAborted callback or any of the .end/.tryEnd calls succeed. You may attach user data to this object. */
+export interface HttpResponse {
+  /** Writes the HTTP status message such as "200 OK".
+   * This has to be called first in any response, otherwise
+   * it will be called automatically with "200 OK".
+   *
+   * If you want to send custom headers in a WebSocket
+   * upgrade response, you have to call writeStatus with
+   * "101 Switching Protocols" before you call writeHeader,
+   * otherwise your first call to writeHeader will call
+   * writeStatus with "200 OK" and the upgrade will fail.
+   *
+   * As you can imagine, we format outgoing responses in a linear
+   * buffer, not in a hash table. You can read about this in
+   * the user manual under "corking".
+   */
+  writeStatus(status: RecognizedString): HttpResponse
+  /** Writes key and value to HTTP response.
+   * See writeStatus and corking.
+   */
+  writeHeader(key: RecognizedString, value: RecognizedString): HttpResponse
+  /** Enters or continues chunked encoding mode. Writes part of the response. End with zero length write. Returns true if no backpressure was added. */
+  write(chunk: RecognizedString): boolean
+  /** Ends this response by copying the contents of body. */
+  end(body?: RecognizedString, closeConnection?: boolean): HttpResponse
+  /** Ends this response, or tries to, by streaming appropriately sized chunks of body. Use in conjunction with onWritable. Returns tuple [ok, hasResponded]. */
+  tryEnd(
+    fullBodyOrChunk: RecognizedString,
+    totalSize: number
+  ): [boolean, boolean]
+
+  /** Immediately force closes the connection. Any onAborted callback will run. */
+  close(): HttpResponse
+
+  /** Returns the global byte write offset for this response. Use with onWritable. */
+  getWriteOffset(): number
+
+  /** Registers a handler for writable events. Continue failed write attempts in here.
+   * You MUST return true for success, false for failure.
+   * Writing nothing is always success, so by default you must return true.
+   */
+  onWritable(handler: (offset: number) => boolean): HttpResponse
+
+  /** Every HttpResponse MUST have an attached abort handler IF you do not respond
+   * to it immediately inside of the callback. Returning from an Http request handler
+   * without attaching (by calling onAborted) an abort handler is ill-use and will termiante.
+   * When this event emits, the response has been aborted and may not be used. */
+  onAborted(handler: () => void): HttpResponse
+
+  /** Handler for reading data from POST and such requests. You MUST copy the data of chunk if isLast is not true. We Neuter ArrayBuffers on return, making it zero length. */
+  onData(handler: (chunk: ArrayBuffer, isLast: boolean) => void): HttpResponse
+
+  /** Returns the remote IP address in binary format (4 or 16 bytes). */
+  getRemoteAddress(): ArrayBuffer
+
+  /** Returns the remote IP address as text. */
+  getRemoteAddressAsText(): ArrayBuffer
+
+  /** Returns the remote IP address in binary format (4 or 16 bytes), as reported by the PROXY Protocol v2 compatible proxy. */
+  getProxiedRemoteAddress(): ArrayBuffer
+
+  /** Returns the remote IP address as text, as reported by the PROXY Protocol v2 compatible proxy. */
+  getProxiedRemoteAddressAsText(): ArrayBuffer
+
+  /** Corking a response is a performance improvement in both CPU and network, as you ready the IO system for writing multiple chunks at once.
+   * By default, you're corked in the immediately executing top portion of the route handler. In all other cases, such as when returning from
+   * await, or when being called back from an async database request or anything that isn't directly executing in the route handler, you'll want
+   * to cork before calling writeStatus, writeHeader or just write. Corking takes a callback in which you execute the writeHeader, writeStatus and
+   * such calls, in one atomic IO operation. This is important, not only for TCP but definitely for TLS where each write would otherwise result
+   * in one TLS block being sent off, each with one send syscall.
+   *
+   * Example usage:
+   *
+   * res.cork(() => {
+   *   res.writeStatus("200 OK").writeHeader("Some", "Value").write("Hello world!");
+   * });
+   */
+  cork(cb: () => void): HttpResponse
+
+  /** Upgrades a HttpResponse to a WebSocket. See UpgradeAsync, UpgradeSync example files. */
+  upgrade<T>(
+    userData: T,
+    secWebSocketKey: RecognizedString,
+    secWebSocketProtocol: RecognizedString,
+    secWebSocketExtensions: RecognizedString,
+    context: any
+  ): void
+
+  /** Arbitrary user data may be attached to this object */
+  [key: string]: any
+}
+
+/** An HttpRequest is stack allocated and only accessible during the callback invocation. */
+export interface HttpRequest {
+  /** Returns the lowercased header value or empty string. */
+  getHeader(lowerCaseKey: RecognizedString): string
+  /** Returns the parsed parameter at index. Corresponds to route. */
+  getParameter(index: number): string
+  /** Returns the URL including initial /slash */
+  getUrl(): string
+  /** Returns the HTTP method, useful for "any" routes. */
+  getMethod(): string
+  /** Returns the raw querystring (the part of URL after ? sign) or empty string. */
+  getQuery(): string
+  /** Returns a decoded query parameter value or empty string. */
+  getQuery(key: string): string
+  /** Loops over all headers. */
+  forEach(cb: (key: string, value: string) => void): void
+  /** Setting yield to true is to say that this route handler did not handle the route, causing the router to continue looking for a matching route handler, or fail. */
+  setYield(y: boolean): HttpRequest
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*", "src/**/*.json"],
+  "exclude": ["node_modules", "test", "dist", "tmp", "examples"]
+}