@stainless-api/docs 0.1.0-beta.86 → 0.1.0-beta.88

package/plugin/cms/server.ts

@@ -1,364 +0,0 @@
-import type { AstroIntegrationLogger } from 'astro';
-import { createServer, IncomingMessage } from 'http';
-import { readFile } from 'fs/promises';
-
-import type * as SDKJSON from '@stainless/sdk-json';
-import { parseRoute, type DocsLanguage } from '@stainless-api/docs-ui/routing';
-import Stainless, { APIError } from '@stainless-api/sdk';
-
-import {
-  toStarlightSidebar,
-  type GeneratedSidebarConfig,
-  SidebarConfigItemsBuilder,
-} from './sidebar-builder';
-import type { VersionUserConfig } from '../loadPluginConfig';
-import { bold } from '../../shared/terminalUtils';
-import { generateSpecFromStrings } from './generate-spec';
-export type InputFilePaths = {
-  oasPath?: string;
-  configPath?: string;
-};
-
-async function versionInfo(project: string, apiKey: string): Promise<Record<DocsLanguage, string>> {
-  const data = await fetch(`https://api.stainless.com/api/projects/${project}/package-versions`, {
-    headers: { Authorization: `Bearer ${apiKey}` },
-  });
-
-  const content = await data.text();
-  return JSON.parse(content) as Record<DocsLanguage, string>;
-}
-
-function redactApiKey(apiKey: string) {
-  return apiKey
-    .split('')
-    .map((char, index) => (index < 10 ? char : '*'))
-    .join('');
-}
-
-export type Auth = Array<{
-  type: 'http_bearer' | 'query' | 'header' | 'oauth2' | 'http_basic' | 'http_digest';
-  description?: string;
-  name: string;
-  title: string;
-  header: string | undefined;
-  example: string | undefined;
-  opts: {
-    type: 'string' | 'number' | 'boolean' | 'null' | 'integer';
-    nullable: boolean;
-    description?: string | undefined;
-    example?: unknown;
-    default?: unknown;
-    read_env?: string | undefined;
-    auth?:
-      | {
-          security_scheme: string;
-          role?: 'value' | 'password' | 'username' | 'client_id' | 'client_secret' | undefined;
-        }
-      | undefined;
-    name: string;
-  }[];
-}>;
-
-type LoadedSpec = { data: SDKJSON.Spec; auth: Auth; id: string };
-
-async function loadSpec({
-  apiKey,
-  devPaths,
-  version,
-  logger,
-  specCacheDirectory,
-}: {
-  apiKey: string;
-  devPaths: InputFilePaths;
-  version: VersionUserConfig;
-  logger: AstroIntegrationLogger;
-  specCacheDirectory: string | null;
-}): Promise<LoadedSpec> {
-  async function unsafeLoad(): Promise<LoadedSpec> {
-    let oasStr: string;
-    let configStr: string;
-    let versions: Record<DocsLanguage, string> | undefined;
-
-    if (devPaths.oasPath && devPaths.configPath) {
-      [oasStr, configStr] = await Promise.all([
-        readFile(devPaths.oasPath, 'utf-8'),
-        readFile(devPaths.configPath, 'utf-8'),
-      ]);
-    } else {
-      const client = new Stainless({ apiKey });
-      const configs = await client.projects.configs.retrieve({
-        project: version.stainlessProject,
-        branch: version.branch,
-        include: 'openapi',
-      });
-
-      versions = await versionInfo(version.stainlessProject, apiKey);
-
-      const configYML = Object.values(configs)[0] as { content: any };
-      const oasJson = Object.values(configs)[1] as { content: any };
-      oasStr = oasJson['content'];
-      configStr = configYML['content'];
-    }
-
-    const sdkJson = await generateSpecFromStrings({
-      oasStr,
-      configStr,
-      projectName: version.stainlessProject,
-      specCacheDirectory,
-    });
-
-    if (versions) {
-      for (const [lang, version] of Object.entries(versions)) {
-        const meta = sdkJson.data.metadata[lang as DocsLanguage];
-        if (meta?.version) meta.version = version;
-      }
-    }
-
-    const id = crypto.randomUUID();
-
-    return {
-      data: sdkJson.data,
-      auth: sdkJson.auth,
-      id,
-    };
-  }
-
-  try {
-    const result = await unsafeLoad();
-    return result;
-  } catch (error) {
-    logger.error(bold('Failed to fetch API reference information from Stainless:'));
-    if (error instanceof APIError && error.status >= 400 && error.status < 500) {
-      logger.error(`Requested project slug: "${version.stainlessProject}"`);
-      logger.error(`API key: "${redactApiKey(apiKey)}"`);
-      logger.error(
-        `This error can usually be corrected by re-authenticating with the Stainless.  Use the CLI (stl auth login) or verify that the Stainless API key you're using can access the project mentioned above.`,
-      );
-    } else {
-      logger.error(error instanceof Error ? error.message : 'Unknown error');
-    }
-
-    process.exit(1);
-  }
-}
-
-class Spec {
-  private specPromise: Promise<{ id: string; data: SDKJSON.Spec; auth: Auth }>;
-  private devPaths: InputFilePaths;
-  private apiKey: string;
-  private version: VersionUserConfig;
-
-  reload() {
-    this.specPromise = loadSpec({
-      specCacheDirectory: this.specCacheDirectory,
-      apiKey: this.apiKey,
-      devPaths: this.devPaths,
-      version: this.version,
-      logger: this.logger,
-    });
-  }
-
-  async forceGetSpec() {
-    const spec = await this.specPromise;
-    return spec;
-  }
-
-  async getSpec(currentId: string | undefined | null) {
-    const spec = await this.specPromise;
-
-    if (currentId === spec.id) {
-      return {
-        id: spec.id,
-        data: null,
-        auth: null,
-      };
-    }
-
-    return spec;
-  }
-
-  constructor(
-    apiKey: string,
-    version: VersionUserConfig,
-    devPaths: InputFilePaths,
-    private logger: AstroIntegrationLogger,
-    private specCacheDirectory: string | null,
-  ) {
-    this.specPromise = loadSpec({
-      specCacheDirectory,
-      apiKey,
-      devPaths,
-      version,
-      logger,
-    });
-    this.devPaths = devPaths;
-    this.apiKey = apiKey;
-    this.version = version;
-    this.logger = logger;
-  }
-}
-
-export type SpecResp = Awaited<ReturnType<Spec['getSpec']>>;
-
-// will be necessary once we add POST methods
-function readJsonBody<T>(req: IncomingMessage): Promise<T> {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    req.on('data', (chunk) => {
-      body += chunk.toString();
-    });
-    req.on('end', () => {
-      try {
-        const data = JSON.parse(body);
-        resolve(data as T);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  });
-}
-
-function markCurrentItems(sidebar: SidebarEntry[], currentSlug: string) {
-  // IMPORTANT: we need to clone the sidebar to avoid mutating the original sidebar
-  const mutableSidebarInstance = structuredClone(sidebar);
-
-  function recursiveMarkCurrent(entries: SidebarEntry[]) {
-    for (const entry of entries) {
-      if (entry.type === 'link') {
-        entry.isCurrent = entry.href === currentSlug;
-        if (entry.isCurrent) {
-          return;
-        }
-      }
-      if (entry.type === 'group') {
-        recursiveMarkCurrent(entry.entries);
-      }
-    }
-  }
-  recursiveMarkCurrent(mutableSidebarInstance);
-
-  return mutableSidebarInstance;
-}
-
-export function startDevServer({
-  port,
-  version,
-  devPaths,
-  apiKey,
-  getGeneratedSidebarConfig,
-  logger,
-  specCacheDirectory,
-}: {
-  port: number;
-  version: VersionUserConfig;
-  devPaths: InputFilePaths;
-  apiKey: string;
-  specCacheDirectory: string | null;
-  getGeneratedSidebarConfig: (id: number) => GeneratedSidebarConfig | null;
-  logger: AstroIntegrationLogger;
-}) {
-  const spec = new Spec(apiKey, version, devPaths, logger, specCacheDirectory);
-
-  const sidebarCache = new Map<string, SidebarEntry[]>();
-
-  const server = createServer(async (req, res) => {
-    // Add CORS headers
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-
-    // Handle preflight requests
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
-    function respond(code: number, body: any) {
-      res.setHeader('Content-Type', 'application/json');
-      res.writeHead(code);
-      res.end(JSON.stringify(body));
-    }
-
-    try {
-      if (req.method === 'POST' && req.url === '/retrieve_spec') {
-        const body = await readJsonBody<{ currentId: string }>(req);
-
-        const currentSpec = await spec.getSpec(body.currentId);
-
-        return respond(200, currentSpec);
-      }
-
-      if (req.method === 'POST' && req.url === '/build_sidebar') {
-        const currentSpec = await spec.forceGetSpec();
-        const body = await readJsonBody<{ sidebarId: number; basePath: string; currentSlug: string }>(req);
-        const sidebarId: number = body.sidebarId;
-
-        const sidebarConfig = getGeneratedSidebarConfig(sidebarId);
-
-        const sidebarGenerateOptions = sidebarConfig?.options;
-
-        const { language } = parseRoute(body.basePath, body.currentSlug);
-
-        const sidebarCacheKey = `${body.basePath}-${language}-${sidebarId}`;
-
-        const cachedSidebar = sidebarCache.get(sidebarCacheKey);
-        let starlightSidebar: SidebarEntry[] | null = null;
-        if (cachedSidebar) {
-          starlightSidebar = cachedSidebar;
-        } else {
-          const configItemsBuilder = new SidebarConfigItemsBuilder(
-            currentSpec.data,
-            language,
-            sidebarGenerateOptions,
-          );
-
-          let userSidebarConfig = configItemsBuilder.generateItems();
-
-          if (sidebarConfig && sidebarConfig.transformFn) {
-            const transformedSidebarConfig = sidebarConfig.transformFn(userSidebarConfig, language);
-            // the user may not have returned, but they may have mutated the config in place
-            // if they did return, we use that
-            if (transformedSidebarConfig) {
-              userSidebarConfig = transformedSidebarConfig;
-            }
-          }
-          starlightSidebar = toStarlightSidebar({
-            basePath: body.basePath,
-            spec: currentSpec.data,
-            entries: userSidebarConfig,
-            currentLanguage: language,
-          });
-
-          sidebarCache.set(sidebarCacheKey, starlightSidebar);
-        }
-
-        return respond(200, { data: markCurrentItems(starlightSidebar, body.currentSlug) });
-      }
-
-      return respond(404, { message: 'Not found' });
-    } catch (e) {
-      return respond(500, { message: 'Unexpected error', error: e });
-    }
-  });
-
-  server.listen(port, () => {
-    logger.debug(`Stainless spec server is running on port: ${port}`);
-  });
-
-  return {
-    invalidate: () => {
-      spec.reload();
-      sidebarCache.clear();
-    },
-    destroy: function destroy() {
-      return new Promise<void>((resolve) => {
-        server.close(() => {
-          resolve();
-        });
-      });
-    },
-  };
-}
-
-export type DevSpecServer = Awaited<ReturnType<typeof startDevServer>>;