@stainless-api/docs 0.1.0-beta.138 → 0.1.0-beta.139

package/plugin/specs/inputResolver.ts

@@ -1,148 +0,0 @@
-import { DocsLanguage } from '@stainless-api/docs-ui/routing';
-import { readFile } from 'fs/promises';
-import { AstroIntegrationLogger } from 'astro';
-import { bold } from '../../shared/terminalUtils';
-import type { LanguageGenerateQuery, LoadedApiKey } from '../loadPluginConfig';
-import Stainless, { APIError } from '@stainless-api/sdk';
-import { GenerateSpecRawInputs } from './generateSpec';
-
-export type SpecInputResolver = {
-  resolve: (context: {
-    apiKey: LoadedApiKey | null;
-  }) => GenerateSpecRawInputs | Promise<GenerateSpecRawInputs>;
-  printError: (error: Error, logger: AstroIntegrationLogger) => void;
-};
-
-function fromFiles({
-  oasPath,
-  configPath,
-  languageOverrides,
-  stainlessProject,
-}: {
-  oasPath: string;
-  configPath: string;
-  languageOverrides: LanguageGenerateQuery | null;
-  stainlessProject: string;
-}): SpecInputResolver {
-  return {
-    resolve: async () => {
-      const oasStr = await readFile(oasPath, 'utf8');
-      const configStr = await readFile(configPath, 'utf8');
-      return {
-        oasStr,
-        configStr,
-        versionInfo: null,
-        languageOverrides,
-        stainlessProject,
-      };
-    },
-    printError: (error: Error, logger: AstroIntegrationLogger) => {
-      logger.error(bold('Failed to resolve spec inputs from files:'));
-      logger.error(error.message);
-    },
-  };
-}
-
-async function fetchVersionInfo(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('');
-}
-
-function fromStainlessApi(inputs: {
-  stainlessProject: string;
-  branch: string;
-  apiKey?: LoadedApiKey;
-  languageOverrides: LanguageGenerateQuery | null;
-}): SpecInputResolver {
-  let apiKey: string | undefined;
-  return {
-    async resolve(context) {
-      apiKey = context.apiKey?.value ?? inputs.apiKey?.value;
-
-      if (!apiKey) {
-        throw new Error('No API key provided');
-      }
-
-      const client = new Stainless({ apiKey });
-      const configs = await client.projects.configs.retrieve({
-        project: inputs.stainlessProject,
-        branch: inputs.branch,
-        include: 'openapi',
-      });
-      const versionInfo = await fetchVersionInfo(inputs.stainlessProject, apiKey);
-
-      const configYML = Object.values(configs)[0] as { content: unknown };
-      const oasJson = Object.values(configs)[1] as { content: unknown };
-      const oasStr = oasJson['content'];
-      const configStr = configYML['content'];
-
-      if (typeof oasStr !== 'string' || typeof configStr !== 'string') {
-        throw new Error('Received invalid OAS or config from Stainless');
-      }
-
-      return {
-        oasStr,
-        configStr,
-        versionInfo,
-        languageOverrides: inputs.languageOverrides,
-        stainlessProject: inputs.stainlessProject,
-      };
-    },
-    printError: (error: Error, logger: AstroIntegrationLogger) => {
-      if (error instanceof APIError && error.status >= 400 && error.status < 500) {
-        logger.error(`Requested project slug: "${inputs.stainlessProject}"`);
-        if (apiKey) {
-          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.`,
-        );
-      }
-    },
-  };
-}
-
-function fromStrings({
-  oasStr,
-  configStr,
-  languageOverrides,
-  stainlessProject,
-}: {
-  oasStr: string;
-  configStr: string;
-  languageOverrides: LanguageGenerateQuery | null;
-  stainlessProject: string;
-}): SpecInputResolver {
-  return {
-    resolve() {
-      return {
-        oasStr,
-        configStr,
-        versionInfo: null,
-        languageOverrides,
-        stainlessProject,
-      };
-    },
-    printError(error: Error, logger: AstroIntegrationLogger) {
-      logger.error(bold('Failed to resolve spec inputs from strings:'));
-      logger.error(error.message);
-    },
-  };
-}
-
-export const resolveSpec = {
-  fromFiles,
-  fromStainlessApi,
-  fromStrings,
-} satisfies Record<string, (...args: never[]) => SpecInputResolver>;

package/plugin/specs/worker.ts

@@ -1,199 +0,0 @@
-import Worker from 'web-worker';
-import { Languages, type DocsLanguage } from '@stainless-api/docs-ui/routing';
-import type * as SDKJSON from '@stainless/sdk-json';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import fs from 'fs/promises';
-import pathutils from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const workerPath = resolve(__dirname, '..', 'vendor', 'preview.worker.docs.js');
-
-type OpenAPIDocument = Record<string, any>;
-export type ParsedConfig = {
-  docs:
-    | {
-        title?: string | undefined;
-        favicon?: string | undefined;
-        logo_icon?: string | undefined;
-        search?:
-          | {
-              algolia?:
-                | {
-                    app_id: string;
-                    index_name: string;
-                    search_key: string;
-                  }
-                | undefined;
-            }
-          | undefined;
-        description?: string | undefined;
-        languages?:
-          | ('node' | 'typescript' | 'python' | 'java' | 'kotlin' | 'go' | 'ruby' | 'terraform' | 'http')[]
-          | undefined;
-        snippets?:
-          | {
-              exclude_languages?: string[] | undefined;
-            }
-          | undefined;
-        show_security?: boolean | undefined;
-        show_readme?: boolean | undefined;
-        base_path?: string | undefined;
-        navigation?:
-          | {
-              menubar?:
-                | {
-                    title: string;
-                    icon?: string;
-                    variant?: string;
-                    href?: string | undefined;
-                    page?: string | undefined;
-                  }[]
-                | undefined;
-              sidebar?:
-                | {
-                    title: string;
-                    icon?: string;
-                    variant?: string;
-                    href?: string | undefined;
-                    page?: string | undefined;
-                  }[]
-                | undefined;
-            }
-          | undefined;
-        pages?: unknown;
-        resources?: unknown[] | undefined;
-      }
-    | undefined;
-  targets: Record<string, { skip?: boolean }>;
-  client_settings: {
-    opts: {
-      [x: string]: {
-        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;
-      };
-    };
-  };
-};
-
-function runJob({ type, signal, data }: { type: string; signal?: AbortSignal; data: any }) {
-  const stainlessWorker = new Worker(workerPath, {
-    type: 'module',
-    name: 'Preview server',
-  });
-
-  return new Promise<any>((resolve, reject) => {
-    stainlessWorker.addEventListener('error', (e) => {
-      e.preventDefault();
-      reject(e);
-    });
-
-    stainlessWorker.addEventListener('messageerror', (e) => {
-      reject(e);
-    });
-
-    stainlessWorker.addEventListener('message', (message) => {
-      if (message.data.type === `${type}_done`) {
-        resolve(message.data);
-      } else if (message.data.type === `${type}_failed`) {
-        const { name, message: errorMessage } = message.data;
-        const err = new Error(errorMessage);
-        err.name = name;
-        reject(err);
-      }
-    });
-
-    if (signal) {
-      signal.onabort = () => reject({ type: 'abort' });
-    }
-
-    if (signal?.aborted) {
-      reject({ type: 'abort' });
-    }
-
-    stainlessWorker.postMessage({ ...data, type });
-  }).finally(() => {
-    stainlessWorker.terminate();
-  });
-}
-
-export async function parseInputs({ oas, config }: { oas: string; config: string }) {
-  const result = await runJob({
-    type: 'parse',
-    data: {
-      oas,
-      config,
-    },
-  });
-
-  return result as {
-    oas: OpenAPIDocument;
-    config: ParsedConfig;
-  };
-}
-
-export async function transformOAS({ oas, config }: { oas: OpenAPIDocument; config: ParsedConfig }) {
-  const result = await runJob({
-    type: 'transform',
-    data: {
-      oas,
-      config,
-    },
-  });
-
-  return result.transformedOAS;
-}
-
-export async function createSDKJSON({
-  oas,
-  config,
-  languages,
-  projectName,
-}: {
-  oas: OpenAPIDocument;
-  config: ParsedConfig;
-  languages: DocsLanguage[];
-  projectName: string;
-}) {
-  const templatePath = resolve(__dirname, '../vendor/templates');
-  const readmeLoader = await Promise.all(
-    Languages.map(async (language) => {
-      const mdfile = pathutils.join(templatePath, `${language}.md`);
-
-      try {
-        const content = await fs.readFile(mdfile);
-        return [language, content.toString()];
-      } catch {
-        return [language, null];
-      }
-    }),
-  );
-
-  const readmeTemplates = Object.fromEntries(readmeLoader);
-
-  const result = await runJob({
-    type: 'preview',
-    data: {
-      oas,
-      config,
-      languages,
-      transform: false,
-      projectName,
-      readmeTemplates,
-    },
-  });
-
-  return result.spec as SDKJSON.Spec;
-}