spiceflow 0.0.1

package/src/jsonRpc.ts

@@ -0,0 +1,43 @@
+// https://www.jsonrpc.org/specification
+
+export type JsonRpcRequestId = string | number | null;
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  method: string;
+  params: JsonValue[];
+  meta?: any
+  id: JsonRpcRequestId;
+}
+
+export interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: JsonValue;
+}
+
+export interface JsonRpcSuccessResponse {
+  jsonrpc: '2.0';
+  result: JsonValue;
+  error?: undefined;
+  id: JsonRpcRequestId;
+  meta?: any;
+}
+
+export interface JsonRpcErrorResponse {
+  jsonrpc: '2.0';
+  result?: undefined;
+  error: JsonRpcError;
+  id: JsonRpcRequestId;
+  meta?: any;
+}
+
+export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;

package/src/server.ts

@@ -0,0 +1,384 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import superjson from 'superjson';
+import { asyncLocalStorage } from './context-internal';
+import { JsonRpcRequest, JsonRpcResponse } from './jsonRpc';
+import { jsonRpcError } from './utils';
+
+export type Method<P extends any[], R> = (
+  ...params: P
+) => Promise<R> | AsyncIterable<R>;
+export type WrapMethodMeta = {
+  name: string;
+  isGenerator: boolean;
+  pathname: string;
+};
+
+export interface WrapMethod {
+  <P extends any[], R = any>(
+    method: Method<P, R>,
+    meta: WrapMethodMeta,
+  ): Method<P, R>;
+}
+
+export function createRpcMethod<P extends any[], R>(
+  method: Method<P, R>,
+  meta: WrapMethodMeta,
+  customWrapRpcMethod: unknown,
+): Method<P, R> {
+  let wrapped = method;
+  if (typeof customWrapRpcMethod === 'function') {
+    wrapped = customWrapRpcMethod(method, meta);
+    if (typeof wrapped !== 'function') {
+      throw new Error(
+        `wrapMethod didn't return a function, got "${typeof wrapped}"`,
+      );
+    }
+  } else if (
+    customWrapRpcMethod !== undefined &&
+    customWrapRpcMethod !== null
+  ) {
+    throw new Error(
+      `Invalid wrapMethod type, expected "function", got "${typeof customWrapRpcMethod}"`,
+    );
+  }
+  return (...args) => wrapped(...args);
+}
+
+type MethodsMap = {
+  [key: string]: () => Promise<{
+    [key: string]: Method<any, any>;
+  }>;
+};
+
+export function internalEdgeHandler({
+  methodsMap,
+}: {
+  methodsMap: MethodsMap;
+}) {
+  return async ({ req, basePath }: { req: Request; basePath: string }) => {
+    const body = await req.json();
+    const res = new Response();
+    const result = await asyncLocalStorage.run({ req, res }, () =>
+      handler({
+        methodsMap,
+        body,
+        pathname: new URL(req.url).pathname,
+        basePath,
+        method: req.method,
+      }),
+    );
+
+    if (isAsyncGenerator(result)) {
+      const encoder = new TextEncoder();
+      let generatorFinished = false;
+
+      req.signal.addEventListener('abort', () => {
+        if (!generatorFinished) {
+          console.log(`request aborted, cancelling generator`);
+          result.return?.(undefined);
+        }
+      });
+      const readableStream = new ReadableStream(
+        {
+          start(controller) {},
+          async pull(controller) {
+            while (true) {
+              const { done, value } = await result.next();
+              if (done) {
+                break;
+              }
+              controller.enqueue(
+                encoder.encode('data: ' + JSON.stringify(value.json) + '\n\n'),
+              );
+            }
+            generatorFinished = true;
+            controller.close();
+          },
+
+          cancel() {},
+        },
+        // { highWaterMark: 0 },
+      );
+
+      return new Response(readableStream, {
+        headers: {
+          'content-type': 'text/event-stream',
+          'cache-control': 'no-cache',
+          connection: 'keep-alive',
+        },
+      });
+    }
+
+    const { status, json } = result;
+    return new Response(JSON.stringify(json, null, 2), {
+      status,
+      headers: res?.headers || {
+        'content-type': 'application/json',
+      },
+    });
+  };
+}
+
+export function internalNodeJsHandler({
+  methodsMap,
+}: {
+  methodsMap: MethodsMap;
+}) {
+  return async ({
+    req,
+    res,
+    basePath,
+  }: {
+    req: IncomingMessage;
+    res: ServerResponse;
+    basePath: string;
+  }) => {
+    let body = req['body'];
+    if (body && typeof body === 'string') {
+      // if the sdk send a request without content-type header as json, it will be a string
+      body = JSON.parse(body);
+    }
+    if (!body) {
+      // if used outside of next.js, the body is not available
+      try {
+        body = await readReqJson(req);
+      } catch (error) {
+        res.writeHead(400);
+        res.end(
+          JSON.stringify(
+            jsonRpcError({ message: 'Invalid body, must be JSON' }),
+          ),
+        );
+        return;
+      }
+    }
+
+    const result = await asyncLocalStorage.run({ req, res }, () =>
+      handler({
+        methodsMap,
+        body,
+        basePath,
+        pathname: req.url!,
+        method: req.method!,
+      }),
+    );
+
+    if (isAsyncGenerator(result)) {
+      res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+        // https://github.com/vercel/next.js/issues/9965#issuecomment-584319868
+        'content-encoding': 'none',
+      });
+
+      let generatorFinished = false;
+      // handle cancellation
+      res.on('close', () => {
+        if (!generatorFinished) {
+          console.log(`response closed, cancelling generator`);
+          (result as AsyncIterator<any>).return?.();
+        }
+      });
+      while (true) {
+        const { done, value } = await result.next();
+        if (done) {
+          break;
+        }
+        res.write('data: ' + JSON.stringify(value.json) + '\n\n');
+      }
+      generatorFinished = true;
+
+      res.end();
+      return;
+    }
+    const { status, json } = result;
+    res.writeHead(status || 200).end(JSON.stringify(json, null, 2));
+  };
+}
+
+function isAsyncGenerator(obj: any): obj is AsyncGenerator<any> {
+  return obj != null && typeof obj.next === 'function';
+}
+
+const handler = async ({
+  method,
+  methodsMap,
+  basePath,
+  body,
+  pathname,
+}: {
+  method: string;
+  basePath: string;
+  pathname: string;
+  methodsMap: MethodsMap;
+  body: JsonRpcRequest;
+}) => {
+  if (!methodsMap) {
+    throw new Error('No methods found');
+  }
+  if (basePath && pathname.startsWith(basePath)) {
+    if (basePath.endsWith('/')) {
+      basePath = basePath.slice(0, -1);
+    }
+    pathname = pathname.slice(basePath.length);
+  }
+  if (method !== 'POST') {
+    return {
+      status: 405,
+      json: {
+        jsonrpc: '2.0',
+        id: null,
+        error: {
+          code: -32001,
+          message: 'Server error',
+          data: {
+            cause: `HTTP method "${method}" is not allowed`,
+          },
+        },
+      } satisfies JsonRpcResponse,
+    };
+  }
+
+  const { id, method: fn, params, meta: argsMeta } = body;
+
+  const mod = methodsMap[pathname] && (await methodsMap[pathname]());
+  if (!mod) {
+    return {
+      status: 400,
+      json: {
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code: -32601,
+          message: 'Method not found',
+          data: {
+            cause: `Path "${pathname}" is not handled by any method`,
+          },
+        },
+      } satisfies JsonRpcResponse,
+    };
+  }
+
+  const requestedMethod = mod[fn];
+
+  if (typeof requestedMethod !== 'function') {
+    return {
+      status: 400,
+      json: {
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code: -32601,
+          message: 'Method not found',
+          data: {
+            cause: `Method "${fn}" is not a function, in ${Object.keys(
+              mod,
+            ).join(', ')}`,
+          },
+        },
+      } satisfies JsonRpcResponse,
+    };
+  }
+
+  try {
+    const args = superjson.deserialize({
+      json: params,
+      meta: argsMeta,
+    }) as any[];
+    const result = await requestedMethod(...args);
+    if (!isAsyncGenerator(result)) {
+      const { json, meta } = superjson.serialize(result);
+
+      return {
+        json: {
+          jsonrpc: '2.0',
+          id,
+          result: json as any,
+          meta,
+        } satisfies JsonRpcResponse,
+      };
+    }
+    return (async function* () {
+      // send a response for each yielded value
+
+      try {
+        while (true) {
+          const { done, value } = await result.next();
+          if (done) {
+            break;
+          }
+          const { json, meta } = superjson.serialize(value);
+
+          yield {
+            json: {
+              jsonrpc: '2.0',
+              id,
+              result: json as any,
+              meta,
+            } satisfies JsonRpcResponse,
+          };
+        }
+      } catch (error) {
+        const {
+          name = 'RpcError',
+          message = `Invalid value thrown in "${method}", must be instance of Error`,
+          stack = undefined,
+        } = error instanceof Error ? error : {};
+        return {
+          json: {
+            jsonrpc: '2.0',
+            id,
+            error: {
+              code: 1,
+              message,
+              data: {
+                name,
+                ...(process.env.NODE_ENV === 'production' ? {} : { stack }),
+              },
+            },
+          } satisfies JsonRpcResponse,
+        };
+      }
+    })();
+  } catch (error) {
+    const {
+      name = 'RpcError',
+      message = `Invalid value thrown in "${method}", must be instance of Error`,
+      stack = undefined,
+    } = error instanceof Error ? error : {};
+    return {
+      status: 502,
+      json: {
+        jsonrpc: '2.0',
+        id,
+        error: {
+          code: 1,
+          message,
+          data: {
+            name,
+            ...(process.env.NODE_ENV === 'production' ? {} : { stack }),
+          },
+        },
+      } satisfies JsonRpcResponse,
+    };
+  }
+};
+
+function readReqJson(req: IncomingMessage) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', (chunk) => {
+      data += chunk;
+    });
+
+    req.on('end', () => {
+      try {
+        const parsedData = JSON.parse(data);
+        resolve(parsedData);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}

package/src/utils.ts

@@ -0,0 +1,61 @@
+import { PluginPass, parse } from '@babel/core';
+
+import { Node, types } from '@babel/core';
+import { JsonRpcError, JsonRpcErrorResponse } from './jsonRpc';
+
+const PURE_ANNOTATION = '#__PURE__';
+
+export function annotateAsPure<N extends Node>(t: typeof types, node: N): N {
+  t.addComment(node, 'leading', PURE_ANNOTATION);
+  return node;
+}
+
+export type Literal =
+  | number
+  | string
+  | boolean
+  | { [key: string]: Literal }
+  | Literal[];
+
+const enabled = !!process.env.DEBUG_ACTIONS;
+export const logger = {
+  log(...args) {
+    enabled && console.log('[actions]:', ...args);
+  },
+  error(...args) {
+    enabled && console.log('[actions]:', ...args);
+  },
+};
+
+export function getFileName(state: PluginPass) {
+  const { filename, cwd } = state;
+
+  if (!filename) {
+    return undefined;
+  }
+
+  if (cwd && filename.startsWith(cwd)) {
+    return filename.slice(cwd.length + 1);
+  }
+
+  return filename;
+}
+export const directive = "use spiceflow"
+
+export const serverEntryName = '_function_server_file';
+
+export function jsonRpcError({
+  id = null,
+  message,
+  code = 1,
+}): JsonRpcErrorResponse {
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code,
+      message,
+      data: null,
+    },
+  };
+}