spiceflow 0.0.6 → 1.0.0

package/src/build.ts

@@ -1,298 +0,0 @@
-import pico from 'picocolors';
-import fsx from 'fs-extra';
-
-import {
-  ConsoleMessageId,
-  Extractor,
-  ExtractorConfig,
-  ExtractorLogLevel,
-} from '@microsoft/api-extractor';
-import chokidar from 'chokidar';
-import { getPackages } from '@manypkg/get-packages';
-
-import { transform } from '@babel/core';
-import { exec } from 'child_process';
-import globSync from 'fast-glob';
-import fs from 'fs';
-import path from 'path';
-import { plugins } from './index.js';
-import { camelCaseCapitalized, directive, removeExtension } from './utils.js';
-import { WrapMethodMeta } from './server.js';
-
-type BuildOptions = {
-  openapi?: boolean;
-  rootDir: string;
-  url: string;
-  watch?: boolean;
-};
-export async function buildOnce({
-  openapi = false,
-  rootDir,
-  url,
-}: BuildOptions) {
-  console.log();
-  console.log('building functions');
-  if (url && !url.endsWith('/')) {
-    // make sure that new URL uses the last portion of the path too
-    url += '/';
-  }
-  try {
-    new URL(url);
-  } catch (e) {
-    throw new Error(`Invalid url ${url}`);
-  }
-
-  let browserOutDir = path.resolve('client');
-  fs.mkdirSync(browserOutDir, { recursive: true });
-
-  // await fs.promises.rm(browserOutDir, { recursive: true }).catch(() => null);
-
-  const cwd = process.cwd();
-  const serverEntrypoint = path.resolve(rootDir, 'server.ts');
-
-  try {
-    const globBase = path.relative(cwd, rootDir);
-    const globs = [path.posix.join(globBase, '**/*.{ts,tsx,js,jsx}')];
-    // console.log({ globs });
-    const allPossibleFiles = globSync.globSync(globs, {
-      onlyFiles: true,
-      absolute: true,
-    });
-    const actionFilesRelativePaths = allPossibleFiles
-      .filter((file) => {
-        const content = fs.readFileSync(file, 'utf8');
-        return content.includes(directive);
-      })
-      .map((x) => {
-        return path.relative(rootDir, x);
-      });
-    const importsCode = [...new Set(actionFilesRelativePaths)]
-      .map((filePath) => {
-        filePath = removeExtension(filePath);
-        return `${JSON.stringify(
-          '/' + filePath,
-        )}: () => import('./${filePath}.js')`;
-      })
-      .join(',');
-    const serverExposeContent =
-      `// this file was generated\n` +
-      `import { internalEdgeHandler, internalNodeJsHandler } from 'spiceflow/dist/server.js';\n` +
-      `export const methodsMap = {${importsCode}} as any\n` +
-      `export const edgeHandler = internalEdgeHandler({ methodsMap });\n` +
-      `export const nodeJsHandler = internalNodeJsHandler({ methodsMap });\n`;
-
-    if (!actionFilesRelativePaths.length) {
-      throw new Error('No functions files found!');
-    }
-    fs.writeFileSync(serverEntrypoint, serverExposeContent, 'utf8');
-
-    if (fs.existsSync('src/index.ts')) {
-      fs.copyFileSync('src/index.ts', 'client/index.ts');
-    }
-
-    for (let actionFile of actionFilesRelativePaths) {
-      const abs = path.resolve(rootDir, actionFile);
-      const content = fs.readFileSync(abs, 'utf8');
-
-      const actionName = path.basename(actionFile, path.extname(actionFile));
-
-      let methods = [] as WrapMethodMeta[];
-      const res = transform(content || '', {
-        babelrc: false,
-        sourceType: 'module',
-        plugins: [
-          ...plugins({
-            isServer: false,
-            url,
-            onMethod(meta) {
-              methods.push(meta);
-            },
-            rootDir,
-          }),
-        ],
-        filename: abs,
-
-        sourceMaps: false,
-      });
-
-      if (!res || !res.code) {
-        console.error(
-          `Error transforming ${actionFile}, returned nothing, maybe not an action?`,
-        );
-        continue;
-      }
-      const importPath =
-        './' +
-        path.posix.join(path.posix.dirname(actionFile), actionName + '.ts');
-      const outFile = path.resolve(browserOutDir, importPath);
-
-      console.log(`processed ${importPath}`);
-
-      fs.mkdirSync(path.dirname(outFile), {
-        recursive: true,
-      });
-      fs.writeFileSync(outFile, res.code, 'utf-8');
-    }
-  } finally {
-    // await fs.promises.unlink(serverEntrypoint).catch(() => null);
-  }
-}
-
-export async function bundleTypes({ rootDir }) {
-  const browserIndexFile = path.resolve('dist/client/index.d.ts');
-
-  if (!fs.existsSync(browserIndexFile)) {
-    return;
-  }
-
-  const bundledPackages = (await getPackages(process.cwd())).packages.map(
-    (x) => x.packageJson.name,
-  );
-  if (!bundledPackages.length) {
-    console.log('no workspace packages found, skipping types bundling');
-    return;
-  }
-
-  rollupDtsFile({
-    bundledPackages,
-    inputFilePath: browserIndexFile,
-    outputFilePath: browserIndexFile,
-    tsconfigFilePath: 'tsconfig.json',
-  });
-  console.log(`types bundled in ${browserIndexFile}`);
-}
-
-const logger = console;
-
-let isBuilding = { ref: false };
-let missedWatch = { ref: false };
-
-export async function build(options: BuildOptions) {
-  await buildOnce(options);
-  if (!options.watch) {
-    return;
-  }
-  const { rootDir, url } = options;
-  const watcher = chokidar.watch(rootDir, {
-    // ignored: /(^|[\/\\])\../, // ignore dotfiles
-    ignored: [
-      '**/node_modules/**',
-      '**/dist/**',
-      path.resolve(`src/server.ts`),
-      'client/**',
-    ],
-    persistent: true,
-  });
-  console.log('watching for changes');
-  watcher.on('change', async (path, stats) => {
-    if (isBuilding.ref) {
-      missedWatch.ref = true;
-      return;
-    }
-    isBuilding.ref = true;
-    try {
-      logger.log(`detected change in ${path}`);
-      await buildOnce(options);
-      if (missedWatch.ref) {
-        // logger.log('missed a change, rebuilding');
-        await buildOnce(options);
-        missedWatch.ref = false;
-      }
-    } finally {
-      isBuilding.ref = false;
-    }
-  });
-}
-
-function rollupDtsFile({
-  inputFilePath,
-  outputFilePath,
-  tsconfigFilePath,
-  bundledPackages,
-}: {
-  inputFilePath: string;
-  outputFilePath: string;
-  tsconfigFilePath: string;
-  bundledPackages: string[];
-}) {
-  let cwd = process.cwd();
-  if (!fs.existsSync(tsconfigFilePath)) {
-    throw new Error(`tsconfig.json not found at ${tsconfigFilePath}`);
-  }
-
-  let packageJsonFullPath = path.join(cwd, 'package.json');
-
-  const extractorConfig = ExtractorConfig.prepare({
-    configObject: {
-      mainEntryPointFilePath: inputFilePath,
-      bundledPackages,
-      apiReport: {
-        enabled: false,
-
-        // `reportFileName` is not been used. It's just to fit the requirement of API Extractor.
-        reportFileName: 'report.html',
-      },
-      docModel: { apiJsonFilePath: 'api.json', enabled: false },
-      dtsRollup: {
-        enabled: true,
-        untrimmedFilePath: outputFilePath,
-      },
-      tsdocMetadata: { enabled: false, tsdocMetadataFilePath: 'another.json' },
-      compiler: {
-        tsconfigFilePath: tsconfigFilePath,
-      },
-
-      projectFolder: cwd,
-    },
-    configObjectFullPath: undefined,
-    packageJsonFullPath,
-  });
-
-  // Invoke API Extractor
-  const extractorResult = Extractor.invoke(extractorConfig, {
-    // Equivalent to the "--local" command-line parameter
-    localBuild: true,
-
-    messageCallback: (message) => {
-      switch (message.messageId) {
-        case ConsoleMessageId.ApiReportCreated:
-          message.logLevel = ExtractorLogLevel.None;
-          break;
-        case ConsoleMessageId.Preamble:
-          message.logLevel = ExtractorLogLevel.None;
-          break;
-      }
-    },
-    showDiagnostics: false,
-    // Equivalent to the "--verbose" command-line parameter
-    showVerboseMessages: false,
-  });
-
-  if (!extractorResult.succeeded) {
-    throw new Error(
-      `API Extractor completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings when processing ${inputFilePath}`,
-    );
-  }
-}
-
-function runCommand(command: string) {
-  return new Promise((resolve, reject) => {
-    exec(command, {}, (error, stdout, stderr) => {
-      if (error) {
-        console.log();
-        console.error(pico.red(stdout));
-        console.error(pico.red(stderr));
-        reject(error);
-      } else {
-        resolve(stdout);
-      }
-    });
-  });
-}
-
-function openapiTypesPath(outFile) {
-  return path.resolve(
-    path.dirname(outFile),
-    `${path.basename(outFile, path.extname(outFile))}-schema.d.ts`,
-  );
-}

package/src/cli.ts

@@ -1,132 +0,0 @@
-#! /usr/bin/env node
-import os from 'os';
-import fsx from 'fs-extra';
-
-import fs from 'fs-extra';
-
-import { cac } from 'cac';
-import { build, buildOnce, bundleTypes } from './build.js';
-import { findRootDir } from './index.js';
-import { exec, execSync, spawn } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-export const cli = cac();
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-cli
-  .command('', 'Generate an SDK package for your functions')
-  .alias('build')
-  .option('--watch', 'Watch for changes')
-  .option('--url <url>', 'URL of the package, including the base path', {
-    default: 'http://localhost:3333',
-  })
-  .option(
-    '--openapi',
-    '[experimental] Creates an openapi.json schema based on your functions',
-  )
-  .action(async (options) => {
-    const { url, watch, openapi } = options;
-    const rootDir = await findRootDir(process.cwd());
-    await build({ rootDir, url, openapi, watch });
-  });
-
-cli
-  .command('types', 'Bundle browser types')
-
-  .action(async (options) => {
-    const rootDir = await findRootDir(process.cwd());
-    await bundleTypes({ rootDir });
-  });
-
-cli
-  .command('init', 'Generate a new spiceflow project')
-  .option('--name <name>', 'Name of this project')
-  .action(async (options) => {
-    // copy contents of the template dir here
-    const { name } = options;
-    if (!name) {
-      throw new Error('--name is required');
-    }
-    fsx.copySync(path.resolve(__dirname, '../sdk-template'), name, {
-      filter(pathname) {
-        return !pathname.endsWith('.tsbuildinfo');
-      },
-    });
-    // replace the package.json name
-    const packageJsonPath = path.resolve(name, 'package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    packageJson.name = name;
-    delete packageJson.private;
-    // replace workspace:* with * from the package.json
-    for (const key of Object.keys(packageJson.dependencies || {})) {
-      const value = packageJson.dependencies[key];
-      if (value && value.startsWith('workspace:')) {
-        packageJson.dependencies[key] = '*';
-      }
-    }
-
-    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  });
-cli
-  .command('serve', 'Expose a server for your functions')
-  .option('--basePath', 'base path for the server', { default: '/' })
-  .option('--port <port>', 'Port to listen on', { default: '3333' })
-  .option('--watch', 'Watch for changes')
-  .option(
-    '--skip-build',
-    'Skip building the server and SDK, you must build it yourself first',
-  )
-  .action(async (options) => {
-    let { basePath, skipBuild, watch, port } = options;
-    const nodePath = process.execPath || 'node';
-    const rootDir = await findRootDir(process.cwd());
-    if (!skipBuild) {
-      await build({ rootDir, watch, url: `http://127.0.0.1:${port}` });
-    }
-
-    const tempFilePath = path.resolve('_main.mjs');
-
-    const code = `import { methodsMap } from './server/index.js'; import { exposeNodeServer } from 'spiceflow/dist/expose.js'; exposeNodeServer({ methodsMap, basePath: '${basePath}', port: ${port} });`;
-    fs.writeFileSync(tempFilePath, code);
-    process.on('SIGINT', () => {
-      try {
-        fs.unlinkSync(tempFilePath);
-      } catch {}
-      process.exit(0);
-    });
-    // only enable watch if it's supported by node version
-    const major = parseInt(process.version.replace('v', '').split('.')[0]);
-    if (major && major < 18) {
-      console.log(`node version ${process.version} does not support --watch`);
-      watch = false;
-    }
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const p = spawn(
-          `${nodePath} --no-warnings ${watch ? '--watch' : ''} ${JSON.stringify(
-            tempFilePath,
-          )}`,
-          {
-            stdio: 'inherit',
-            shell: true,
-          },
-        );
-        p.on('close', (code) => {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject();
-          }
-        });
-      });
-    } finally {
-      fs.unlinkSync(tempFilePath);
-    }
-  });
-
-cli.help();
-
-cli.parse();

package/src/context-internal.ts

@@ -1,36 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks';
-import type { IncomingMessage, ServerResponse } from 'http';
-
-interface CommonContext {
-  // cookies(): ReadonlyRequestCookies;
-  // headers(): ReadonlyHeaders;
-}
-interface NodejsContext extends CommonContext {
-  req?: IncomingMessage;
-  res?: ServerResponse;
-}
-interface EdgeContext extends CommonContext {
-  req?: Request;
-  res?: Response;
-}
-
-const DEFAULT_CONTEXT = {
-  // headers() {},
-  // cookies() {},
-};
-
-export const asyncLocalStorage = new AsyncLocalStorage<
-  NodejsContext | EdgeContext
->();
-
-export function getNodejsContext(): NodejsContext {
-  return (asyncLocalStorage.getStore() as NodejsContext) || DEFAULT_CONTEXT;
-}
-
-export function getEdgeContext(): EdgeContext {
-  return (asyncLocalStorage.getStore() as EdgeContext) || DEFAULT_CONTEXT;
-}
-
-export function getContext(): CommonContext {
-  return asyncLocalStorage.getStore() || DEFAULT_CONTEXT;
-}

package/src/context.ts

@@ -1,5 +0,0 @@
-export {
-  getNodejsContext,
-  getEdgeContext,
-  getContext,
-} from './context-internal.js';

package/src/expose.ts

@@ -1,34 +0,0 @@
-import http from 'http';
-import { internalNodeJsHandler } from './server.js';
-
-export async function exposeNodeServer({ methodsMap, basePath, port }) {
-  const handler = internalNodeJsHandler({ methodsMap });
-
-  const server = http.createServer(async (req, res) => {
-    let ended = false;
-    res.on('close', () => {
-      ended = true;
-    });
-
-    try {
-      if (req.method === 'GET' && req.url === '/') {
-        res.statusCode = 200;
-        res.end('ok');
-        return;
-      }
-      console.log(`[spiceflow] ${req.url}`);
-      await handler({ req, res, basePath });
-    } catch (error) {
-      if (ended) {
-        return;
-      }
-      console.error(error);
-
-      res.statusCode = 500;
-      res.end('Internal server error');
-    }
-  });
-  server.listen(port, () => {
-    console.log(`server listening on http://127.0.0.1:${port}`);
-  });
-}

package/src/headers.ts

@@ -1,19 +0,0 @@
-// import { asyncLocalStorage } from './context-internal';
-
-// function myHeaders() {
-//   const res = asyncLocalStorage.getStore()?.headers();
-//   if (!res) {
-//     throw new Error('Called headers() outside of app dir or rpc actions');
-//   }
-//   return res;
-// }
-
-// function myCookies() {
-//   const res = asyncLocalStorage.getStore()?.cookies();
-//   if (!res) {
-//     throw new Error('Called cookies() outside of app dir or rpc actions');
-//   }
-//   return res;
-// }
-
-// export { myCookies as cookies, myHeaders as headers };

package/src/index.ts

@@ -1,34 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { PluginOptions } from './babelTransformRpc.js';
-
-import { WrapMethod, WrapMethodMeta } from './server.js';
-
-export interface WithRpcConfig {}
-
-export { WrapMethod };
-
-import pluginSyntaxJsx from '@babel/plugin-syntax-jsx';
-import pluginTransformTypescript from '@babel/plugin-syntax-typescript';
-import babelTransformRpc from './babelTransformRpc.js';
-import babelDebugOutputs from './babelDebugOutputs.js';
-
-export function plugins(options: PluginOptions) {
-  return [
-    pluginSyntaxJsx,
-    [pluginTransformTypescript, { isTSX: true }],
-    [babelTransformRpc, options],
-    process.env.DEBUG_ACTIONS && [babelDebugOutputs, options],
-  ].filter(Boolean);
-}
-
-export function findRootDir(dir: string): string {
-  {
-    let curDir = path.resolve(dir, 'src');
-    if (fs.existsSync(curDir)) return path.resolve(curDir);
-  }
-
-  throw new Error(
-    "Couldn't find a src directory. Please create one under the project root",
-  );
-}

package/src/jsonRpc.ts

@@ -1,43 +0,0 @@
-// 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;