spiceflow 0.0.1

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "spiceflow",
+  "version": "0.0.1",
+  "description": "If GraphQL, JSON-RPC and React server actions had a baby, it would be called spiceflow",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/remorses/spiceflow",
+  "bin": "dist/cli.js",
+  "files": [
+    "dist",
+    "src",
+    "sdk-template",
+    "esm",
+    "context.d.ts",
+    "context.js",
+    "headers.d.ts",
+    "headers.js"
+  ],
+  "keywords": [],
+  "author": "Tommaso De Rossi, morse <beats.by.morse@gmail.com>",
+  "license": "",
+  "peerDependencies": {
+    "next": ">=10"
+  },
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/parser": "^7.24.0",
+    "@babel/plugin-syntax-jsx": "^7.23.3",
+    "@babel/plugin-syntax-typescript": "^7.23.3",
+    "@babel/plugin-transform-typescript": "^7.23.6",
+    "@manypkg/get-packages": "^2.2.1",
+    "@microsoft/api-extractor": "^7.43.1",
+    "@types/fs-extra": "^11.0.4",
+    "cac": "^6.7.14",
+    "chokidar": "^3.6.0",
+    "eventsource-parser": "^1.1.2",
+    "fast-glob": "^3.3.2",
+    "find-up": "^7.0.0",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.0.0",
+    "superjson": "^1.13.3",
+    "ts-json-schema-generator": "^2.1.0"
+  },
+  "devDependencies": {
+    "@babel/generator": "^7.23.6",
+    "@babel/types": "^7.24.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "20.2.5",
+    "next": "14.2.1",
+    "webpack": "^5.88.2"
+  },
+  "scripts": {
+    "build": "cp ../README.md ./README.md && rm -rf ./sdk-template ../sdk-template/dist ../sdk-template/node_modules && cp -r ../sdk-template ./sdk-template && rm -rf dist && tsc",
+    "watch": "tsc -w"
+  }
+}

package/sdk-template/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "sdk-template",
+  "version": "0.0.0",
+  "description": "Spiceflow API template",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "spiceflow --url http://localhost:3333",
+    "watch": "spiceflow --watch --url http://localhost:3333",
+    "serve": "spiceflow serve --port 3333"
+  },
+  "dependencies": {
+    "spiceflow": "workspace:*"
+  },
+  "devDependencies": {}
+}

package/sdk-template/src/index.ts

@@ -0,0 +1,2 @@
+export * from './v1/example';
+export * from './v1/generator';

package/sdk-template/src/v1/example.ts

@@ -0,0 +1,5 @@
+"use spiceflow"
+
+export async function action({  }) {
+  return 'hello';
+}

package/sdk-template/src/v1/generator.ts

@@ -0,0 +1,12 @@
+"use spiceflow"
+
+export async function* generator() {
+  for (let i = 0; i < 10; i++) {
+    await sleep(300);
+    yield { i };
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/sdk-template/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "rootDir": "src",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "skipLibCheck": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noImplicitAny": false
+  },
+  "exclude": ["node_modules", "dist", "scripts"]
+}

package/src/babel.test.ts

@@ -0,0 +1,35 @@
+import { test, expect, describe } from 'vitest';
+import { parseExpression } from '@babel/parser';
+import generate from '@babel/generator';
+import { exportDefaultDeclaration } from '@babel/types';
+
+// import { parseExpression } from './utils';
+
+test('parseExpression', () => {
+  {
+    const parsed = parseExpression(
+      '{ "type": "StringLiteral", "value": "/api/actions-node" }',
+    );
+    const code = generate(parsed).code;
+    expect(code).toMatchInlineSnapshot(`
+      "{
+        "type": "StringLiteral",
+        "value": "/api/actions-node"
+      }"
+    `);
+  }
+  {
+    const parsed = parseExpression('null');
+    const code = generate(parsed).code;
+    expect(code).toMatchInlineSnapshot(`"null"`);
+  }
+  {
+    const parsed = parseExpression(
+      `typeof wrapMethod === 'function' ? wrapMethod : undefined`,
+    );
+    const code = generate(parsed).code;
+    expect(code).toMatchInlineSnapshot(
+      `"typeof wrapMethod === 'function' ? wrapMethod : undefined"`,
+    );
+  }
+});

package/src/babelDebugOutputs.ts

@@ -0,0 +1,56 @@
+import * as babel from '@babel/core';
+import generate from '@babel/generator';
+import * as types from '@babel/types';
+import fs from 'fs';
+import { PluginOptions } from './babelTransformRpc';
+import { default as nodePath, default as path } from 'path';
+
+import { getFileName, logger } from './utils';
+
+type Babel = { types: typeof types };
+
+let deletedDir = false;
+
+export default function debugOutputsPlugin(
+  { types: t }: Babel,
+  { isServer }: PluginOptions,
+): babel.PluginObj | undefined {
+  const cwd = process.cwd();
+
+  if (!deletedDir) {
+    deletedDir = true;
+
+    fs.mkdirSync('./actions-outputs', { recursive: true });
+  }
+  return {
+    visitor: {
+      Program: {
+        exit(program, state) {
+          const filePath =
+            getFileName(state) ?? nodePath.join('pages', 'Default.js');
+
+          if (!process.env.DEBUG_ACTIONS) {
+            return;
+          }
+
+          // stringify the AST and print it
+          const output = generate(
+            program.node,
+            {
+              /* options */
+            },
+            this.file.code,
+          );
+          let p = path.resolve(
+            './actions-outputs',
+            isServer ? 'server/' : 'client/',
+            path.relative(cwd, path.resolve(filePath)),
+          );
+          logger.log(`${isServer ? 'server' : 'client'} plugin output:`, p);
+          fs.mkdirSync(path.dirname(p), { recursive: true });
+          fs.writeFileSync(p, output.code);
+        },
+      },
+    },
+  };
+}

package/src/babelTransformRpc.ts

@@ -0,0 +1,404 @@
+import * as babel from '@babel/core';
+import generate from '@babel/generator';
+import { parseExpression } from '@babel/parser';
+import type * as types from '@babel/types';
+import fs from 'fs';
+import path from 'path';
+import { WrapMethodMeta } from './server';
+import { annotateAsPure, directive, logger } from './utils';
+
+type Babel = { types: typeof types };
+
+const { name } = require('../package.json');
+const IMPORT_PATH_SERVER = `${name}/dist/server.js`;
+const IMPORT_PATH_BROWSER = `${name}/dist/browser.js`;
+
+function isAllowedTsExportDeclaration(
+  declaration: babel.NodePath<babel.types.Declaration | null | undefined>,
+): boolean {
+  return (
+    declaration.isTSTypeAliasDeclaration() ||
+    declaration.isTSInterfaceDeclaration()
+  );
+}
+
+const allowedExports = new Set([
+  'revalidate', //
+  'preferredRegion',
+  'runtime',
+  'maxDuration',
+  'fetchCache',
+  'dynamic',
+  'dynamicParams',
+  'GET',
+  'HEAD',
+]);
+
+function getConfigObjectExpression(
+  variable: babel.NodePath<babel.types.VariableDeclarator>,
+) {
+  const identifier = variable.get('id');
+  const init = variable.get('init');
+  if (
+    identifier.isIdentifier() &&
+    identifier.node.name === 'config' &&
+    init.isObjectExpression()
+  ) {
+    const isEdge = isEdgeInConfig(init);
+    return {
+      isEdge,
+    };
+  }
+  if (identifier.isIdentifier() && identifier.node.name === 'runtime') {
+    const isEdge = init.isStringLiteral({ value: 'edge' });
+    return {
+      isEdge,
+    };
+  }
+  return null;
+}
+
+export function getConfigObject(program: babel.NodePath<babel.types.Program>) {
+  for (const statement of program.get('body')) {
+    if (statement.isExportNamedDeclaration()) {
+      const declaration = statement.get('declaration');
+      if (declaration.isVariableDeclaration()) {
+        for (const variable of declaration.get('declarations')) {
+          const configObject = getConfigObjectExpression(variable);
+          if (configObject) {
+            return configObject;
+          }
+        }
+      }
+    }
+  }
+  return;
+}
+
+function isServerAction(program: babel.NodePath<babel.types.Program>): boolean {
+  const dir = program.node.directives?.find(
+    (x) => x.value?.value === directive,
+  );
+  return !!dir;
+  // https://regex101.com/r/Wm6UvV/1
+  // return /^("|')poor man's use server("|')(;?)\n/m.test(code);
+}
+
+function hasWrapMethod(program: babel.NodePath<babel.types.Program>) {
+  // check if there is a function export called wrapMethod
+  for (const statement of program.get('body')) {
+    // also check the export { wrapMethod }
+    if (statement.isExportNamedDeclaration()) {
+      for (const specifier of statement.get('specifiers')) {
+        if (
+          specifier.node.exported.type === 'Identifier' &&
+          specifier.node.exported.name === 'wrapMethod'
+        ) {
+          return true;
+        }
+      }
+    }
+    if (statement.isExportNamedDeclaration()) {
+      const declaration = statement.get('declaration');
+      if (declaration.isFunctionDeclaration()) {
+        const identifier = declaration.get('id');
+        if (identifier.node?.name === 'wrapMethod') {
+          return true;
+        }
+      } else if (declaration.isVariableDeclaration()) {
+        for (const variable of declaration.get('declarations')) {
+          const id = variable.get('id');
+          if (id.isIdentifier() && id.node.name === 'wrapMethod') {
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  // return (
+  //   /export\s+function\s+wrapMethod\s*\(/m.test(code) ||
+  //   /export\s+(let|const)\s+wrapMethod\s*/m.test(code) ||
+  //   // https://regex101.com/r/nRaEVs/1
+  //   /export\s+\{[^}]*wrapMethod/m.test(code)
+  // );
+}
+
+export function isEdgeInConfig(
+  configObject?: babel.NodePath<babel.types.ObjectExpression>,
+): boolean {
+  if (!configObject) {
+    return false;
+  }
+  for (const property of configObject.get('properties')) {
+    if (!property.isObjectProperty()) {
+      continue;
+    }
+    const key = property.get('key');
+    const value = property.get('value');
+
+    if (
+      property.isObjectProperty() &&
+      key.isIdentifier({ name: 'runtime' }) &&
+      value.isStringLiteral({ value: 'edge' })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export interface PluginOptions {
+  isServer: boolean;
+  rootDir: string;
+
+  url?: string;
+}
+
+export default function (
+  { types: t }: Babel,
+  { rootDir, isServer, url: rpcUrl }: PluginOptions,
+): babel.PluginObj {
+  return {
+    visitor: {
+      Program(program) {
+        const { filename } = this.file.opts;
+
+        if (!filename) {
+          return;
+        }
+
+        const { isEdge } = getConfigObject(program) || {
+          isEdge: false,
+        };
+
+        const isAction = isServerAction(program);
+
+        if (!isAction) {
+          logger.log(`Skipping ${filename} because it's not an action`);
+          return;
+        }
+
+        logger.log(
+          `Processing ${filename} as a ${
+            isServer ? 'server' : 'client'
+          } action`,
+        );
+
+        const hasWrap = hasWrapMethod(program);
+
+        const rel = path.relative(rootDir, filename);
+
+        const rpcRelativePath = rel
+          .replace(/\.[j|t]sx?$/, '')
+          // remove /pages at the start
+          .replace(/^src\//, '')
+          .replace(/\/index$/, '');
+        let rpcPath = rpcUrl
+          ? new URL(rpcRelativePath, rpcUrl).toString()
+          : '/' + rpcRelativePath;
+
+        const rpcMethodNames: string[] = [];
+
+        const createRpcMethodIdentifier =
+          program.scope.generateUidIdentifier('createRpcMethod');
+
+        const createRpcMethod = (
+          rpcMethod:
+            | babel.types.ArrowFunctionExpression
+            | babel.types.FunctionExpression,
+          meta: WrapMethodMeta,
+        ) => {
+          return t.callExpression(createRpcMethodIdentifier, [
+            rpcMethod,
+            parseExpression(JSON.stringify(meta)),
+
+            parseExpression(
+              hasWrap
+                ? `typeof wrapMethod === 'function' ? wrapMethod : undefined`
+                : 'null',
+            ),
+          ]);
+        };
+
+        const generators = new Map<string, boolean>();
+        for (const statement of program.get('body')) {
+          if (statement.isExportNamedDeclaration()) {
+            // check if function is async generator
+
+            const declaration = statement.get('declaration');
+            if (isAllowedTsExportDeclaration(declaration)) {
+              // ignore
+            } else if (declaration.isFunctionDeclaration()) {
+              const identifier = declaration.get('id');
+              const methodName = identifier.node?.name;
+              if (methodName === 'wrapMethod') {
+                continue;
+              }
+              const isGenerator = !!declaration.node.generator;
+              generators.set(methodName!, isGenerator);
+              if (!declaration.node.async) {
+                throw declaration.buildCodeFrameError(
+                  'rpc exports must be async functions',
+                );
+              }
+
+              if (methodName) {
+                rpcMethodNames.push(methodName);
+                if (isServer) {
+                  // replace with wrapped
+                  statement.replaceWith(
+                    t.exportNamedDeclaration(
+                      t.variableDeclaration('const', [
+                        t.variableDeclarator(
+                          t.identifier(methodName),
+                          createRpcMethod(t.toExpression(declaration.node), {
+                            name: methodName,
+                            pathname: rpcPath,
+                            isGenerator,
+                          }),
+                        ),
+                      ]),
+                    ),
+                  );
+                }
+              }
+            } else if (
+              declaration.isVariableDeclaration() &&
+              declaration.node.kind === 'const'
+            ) {
+              for (const variable of declaration.get('declarations')) {
+                const init = variable.get('init');
+
+                if (getConfigObjectExpression(variable)) {
+                  continue;
+                }
+                const node = variable.get('id');
+
+                if (node.isIdentifier() && allowedExports.has(node.node.name)) {
+                  continue;
+                }
+                if (getConfigObjectExpression(variable)) {
+                  // ignore, this is the only allowed non-function export
+                  continue;
+                }
+                if (
+                  init.isFunctionExpression() ||
+                  init.isArrowFunctionExpression()
+                ) {
+                  const { id } = variable.node;
+                  if (t.isIdentifier(id)) {
+                    const methodName = id.name;
+                    if (methodName === 'wrapMethod') {
+                      continue;
+                    }
+                  }
+                  if (!init.node.async) {
+                    throw init.buildCodeFrameError(
+                      'rpc exports must be async functions',
+                    );
+                  }
+
+                  if (t.isIdentifier(id)) {
+                    const methodName = id.name;
+                    if (methodName === 'wrapMethod') {
+                      continue;
+                    }
+                    const isGenerator = !!init.node.generator;
+                    generators.set(methodName!, isGenerator);
+                    rpcMethodNames.push(methodName);
+                    if (isServer) {
+                      init.replaceWith(
+                        createRpcMethod(init.node, {
+                          name: methodName,
+                          pathname: rpcPath,
+                          isGenerator,
+                        }),
+                      );
+                    }
+                  }
+                } else {
+                  throw variable.buildCodeFrameError(
+                    'rpc exports must be static functions',
+                  );
+                }
+              }
+            } else {
+              for (const specifier of statement.get('specifiers')) {
+                if (
+                  specifier?.node?.exported.type === 'Identifier' &&
+                  specifier?.node?.exported.name === 'wrapMethod'
+                ) {
+                  continue;
+                }
+                throw specifier.buildCodeFrameError(
+                  'rpc exports must be static functions',
+                );
+              }
+            }
+          } else if (statement.isExportDefaultDeclaration()) {
+            throw statement.buildCodeFrameError(
+              'default exports are not allowed in rpc routes',
+            );
+          }
+        }
+
+        if (!isServer) {
+          const createRpcFetcherIdentifier =
+            program.scope.generateUidIdentifier('createRpcFetcher');
+
+          // Clear the whole body
+          out: for (const statement of program.get('body')) {
+            // don't remove if it's an export with name is config or runtime
+            if (statement.isExportNamedDeclaration()) {
+              const declaration = statement.get('declaration');
+              if (declaration.isVariableDeclaration()) {
+                for (const variable of declaration.get('declarations')) {
+                  const configObject = getConfigObjectExpression(variable);
+                  if (configObject) {
+                    continue out;
+                  }
+                }
+              }
+            }
+            statement.remove();
+          }
+
+          program.pushContainer('body', [
+            t.importDeclaration(
+              [
+                t.importSpecifier(
+                  createRpcFetcherIdentifier,
+                  t.identifier('createRpcFetcher'),
+                ),
+              ],
+              t.stringLiteral(IMPORT_PATH_BROWSER),
+            ),
+            ...rpcMethodNames.map((name) => {
+              const isGenerator = !!generators.get(name);
+              return t.exportNamedDeclaration(
+                t.variableDeclaration('const', [
+                  t.variableDeclarator(
+                    t.identifier(name),
+                    annotateAsPure(
+                      t,
+                      t.callExpression(createRpcFetcherIdentifier, [
+                        parseExpression(
+                          JSON.stringify({
+                            url: rpcPath,
+                            method: name,
+                            isGenerator,
+                          }),
+                        ),
+                      ]),
+                    ),
+                  ),
+                ]),
+              );
+            }),
+          ]);
+        }
+      },
+    },
+  };
+}