cribl-mgmt-plane 0.0.2

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "cribl-mgmt-plane",
+  "version": "0.0.2",
+  "author": "Speakeasy",
+  "type": "module",
+  "tshy": {
+    "sourceDialects": [
+      "cribl-mgmt-plane/source"
+    ],
+    "exports": {
+      ".": "./src/index.ts",
+      "./package.json": "./package.json",
+      "./types": "./src/types/index.ts",
+      "./models/errors": "./src/models/errors/index.ts",
+      "./models": "./src/models/index.ts",
+      "./*.js": "./src/*.ts",
+      "./*": "./src/*.ts"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "test": "vitest run src --reporter=junit --outputFile=.speakeasy/reports/tests.xml --reporter=default",
+    "check": "npm run test && npm run lint",
+    "lint": "eslint --cache --max-warnings=0 src",
+    "build": "tshy",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "zod": "^3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.19.0",
+    "@types/node": "^18.19.3",
+    "eslint": "^9.19.0",
+    "globals": "^15.14.0",
+    "tshy": "^2.0.0",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^8.22.0",
+    "vitest": "^3.0.2",
+    "zod": "^3.25.17"
+  },
+  "dependencies": {},
+  "exports": {
+    ".": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/index.ts",
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./types": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/types/index.ts",
+        "types": "./dist/esm/types/index.d.ts",
+        "default": "./dist/esm/types/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/types/index.d.ts",
+        "default": "./dist/commonjs/types/index.js"
+      }
+    },
+    "./models/errors": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/models/errors/index.ts",
+        "types": "./dist/esm/models/errors/index.d.ts",
+        "default": "./dist/esm/models/errors/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/models/errors/index.d.ts",
+        "default": "./dist/commonjs/models/errors/index.js"
+      }
+    },
+    "./models": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/models/index.ts",
+        "types": "./dist/esm/models/index.d.ts",
+        "default": "./dist/esm/models/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/models/index.d.ts",
+        "default": "./dist/commonjs/models/index.js"
+      }
+    },
+    "./*.js": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/*.ts",
+        "types": "./dist/esm/*.d.ts",
+        "default": "./dist/esm/*.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/*.d.ts",
+        "default": "./dist/commonjs/*.js"
+      }
+    },
+    "./*": {
+      "import": {
+        "cribl-mgmt-plane/source": "./src/*.ts",
+        "types": "./dist/esm/*.d.ts",
+        "default": "./dist/esm/*.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/*.d.ts",
+        "default": "./dist/commonjs/*.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js"
+}

package/src/__tests__/assertions.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { fail } from "assert";
+
+export function assertDefined(value: any): any {
+  if (value === undefined) {
+    fail("value is undefined");
+  }
+
+  return value;
+}

package/src/__tests__/criblmgmtplane.test.ts

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { test } from "vitest";
+import { CriblMgmtPlane } from "../index.js";
+import { createTestHTTPClient } from "./testclient.js";
+
+test("Criblmgmtplane Dummy Service Status", async () => {
+  const testHttpClient = createTestHTTPClient("dummyServiceStatus");
+
+  const criblMgmtPlane = new CriblMgmtPlane({
+    serverURL: process.env["TEST_SERVER_URL"] ?? "http://localhost:18080",
+    httpClient: testHttpClient,
+    bearerAuth: process.env["CRIBLMGMTPLANE_BEARER_AUTH"] ?? "value",
+  });
+
+  await criblMgmtPlane.dummyServiceStatus();
+});

package/src/__tests__/files.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { createReadStream } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { Readable } from "node:stream";
+
+export function filesToStream(filePath: string): ReadableStream<Uint8Array> {
+  return Readable.toWeb(
+    createReadStream(filePath),
+  ) as unknown as ReadableStream<Uint8Array>;
+}
+
+export async function filesToByteArray(filePath: string): Promise<Uint8Array> {
+  return new Uint8Array(await readFile(filePath));
+}
+
+export async function filesToString(filePath: string): Promise<string> {
+  return readFile(filePath, "utf8");
+}
+
+export async function streamToByteArray(
+  stream?: ReadableStream<Uint8Array>,
+): Promise<Buffer> {
+  if (!stream) {
+    return Buffer.from("");
+  }
+
+  const chunks = [];
+  const reader = stream.getReader();
+
+  let done = false;
+  while (!done) {
+    const res = await reader.read();
+    done = res.done;
+    if (res.value) {
+      chunks.push(res.value);
+    }
+  }
+
+  return Buffer.concat(chunks);
+}
+
+export function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(bytes);
+    },
+    pull(controller) {
+      controller.close();
+    },
+    cancel() {
+    },
+  });
+}

package/src/__tests__/mockserver/README.md

@@ -0,0 +1,52 @@
+# Mock Server
+
+A generated HTTP mock server based on your OpenAPI Specification (OAS). Use this mock server for integration and contract testing.
+
+## Usage
+
+The server can be built and started via the [Go programming language toolchain](https://go.dev/) or [Docker](https://www.docker.com/).
+
+If you have Go installed, start the server directly via:
+
+```shell
+go run .
+```
+
+Otherwise, if you have Docker installed, build and run the server via:
+
+```shell
+docker build -t mockserver .
+docker run -i -p 18080:18080 -t --rm mockserver
+```
+
+By default, the server runs on port `18080`.
+
+### Server Paths
+
+The server contains generated paths from the OAS and the following additional built-in paths.
+
+| Path | Description |
+|---|---|
+| [`/_mockserver/health`](https://localhost:18080/_mockserver/health) | verify server is running |
+| [`/_mockserver/log`](https://localhost:18080/_mockserver/log) | view per-OAS-operation logs |
+
+Any request outside the generated and built-in paths will return a `404 Not Found` response.
+
+### Server Customization
+
+The server supports the following flags for customization.
+
+| Flag | Default | Description |
+|---|---|---|
+| `-address` | `:18080` | server listen address |
+| `-log-format` | `text` | logging format (supported: `JSON`, `text`) |
+| `-log-level` | `INFO` | logging level (supported: `DEBUG`, `INFO`, `WARN`, `ERROR`) |
+
+For example, enabling server debug logging:
+
+```shell
+# via `go run`
+go run . -log-level=DEBUG
+# via `docker run`
+docker run -i -p 18080:18080 -t --rm mockserver -log-level=DEBUG
+```

package/src/__tests__/testclient.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { getRandomValues } from "crypto";
+import { HTTPClient } from "../lib/http.js";
+
+export function createTestHTTPClient(testName: string): HTTPClient {
+  const httpClient = new HTTPClient({
+    fetcher: (request: URL | RequestInfo) => {
+      return fetch(request);
+    },
+  });
+
+  const testInstanceId = genTestId();
+
+  httpClient.addHook("beforeRequest", (request: Request) => {
+    const nextRequest = new Request(request, {
+      signal: request.signal || AbortSignal.timeout(5000),
+    });
+
+    nextRequest.headers.set("x-speakeasy-test-name", testName);
+    nextRequest.headers.set("x-speakeasy-test-instance-id", testInstanceId);
+
+    return nextRequest;
+  });
+
+  return httpClient;
+}
+
+function genTestId(): string {
+  const b = new Uint8Array(16);
+  getRandomValues(b);
+
+  return `${buf2hex(b.slice(0, 4))}-${buf2hex(b.slice(4, 6))}-${
+    buf2hex(
+      b.slice(6, 8),
+    )
+  }-${buf2hex(b.slice(8, 10))}-${buf2hex(b.slice(10))}`;
+}
+
+// Helper function to convert buffer to hex string
+function buf2hex(buffer: Uint8Array): string {
+  return [...buffer]
+    .map((x) => x.toString(16).padStart(2, "0"))
+    .join("")
+    .toUpperCase();
+}

package/src/core.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "./lib/sdks.js";
+
+/**
+ * A minimal client to use when calling standalone SDK functions. Typically, an
+ * instance of this class would be instantiated once at the start of an
+ * application and passed around through some dependency injection mechanism  to
+ * parts of an application that need to make SDK calls.
+ */
+export class CriblMgmtPlaneCore extends ClientSDK {}

package/src/funcs/dummyServiceStatus.ts

@@ -0,0 +1,139 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { CriblMgmtPlaneCore } from "../core.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import { CriblMgmtPlaneError } from "../models/errors/criblmgmtplaneerror.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * Service status
+ */
+export function dummyServiceStatus(
+  client: CriblMgmtPlaneCore,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    void,
+    | CriblMgmtPlaneError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    options,
+  ));
+}
+
+async function $do(
+  client: CriblMgmtPlaneCore,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      void,
+      | CriblMgmtPlaneError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const path = pathToFunc("/status")();
+
+  const headers = new Headers(compactMap({
+    Accept: "*/*",
+  }));
+
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "dummyServiceStatus",
+    oAuth2Scopes: [],
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const [result] = await M.match<
+    void,
+    | CriblMgmtPlaneError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.nil(200, z.void()),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/hooks/hooks.ts

@@ -0,0 +1,132 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SDKOptions } from "../lib/config.js";
+import { RequestInput } from "../lib/http.js";
+import {
+  AfterErrorContext,
+  AfterErrorHook,
+  AfterSuccessContext,
+  AfterSuccessHook,
+  BeforeCreateRequestContext,
+  BeforeCreateRequestHook,
+  BeforeRequestContext,
+  BeforeRequestHook,
+  Hook,
+  Hooks,
+  SDKInitHook,
+} from "./types.js";
+
+import { initHooks } from "./registration.js";
+
+export class SDKHooks implements Hooks {
+  sdkInitHooks: SDKInitHook[] = [];
+  beforeCreateRequestHooks: BeforeCreateRequestHook[] = [];
+  beforeRequestHooks: BeforeRequestHook[] = [];
+  afterSuccessHooks: AfterSuccessHook[] = [];
+  afterErrorHooks: AfterErrorHook[] = [];
+
+  constructor() {
+    const presetHooks: Array<Hook> = [];
+
+    for (const hook of presetHooks) {
+      if ("sdkInit" in hook) {
+        this.registerSDKInitHook(hook);
+      }
+      if ("beforeCreateRequest" in hook) {
+        this.registerBeforeCreateRequestHook(hook);
+      }
+      if ("beforeRequest" in hook) {
+        this.registerBeforeRequestHook(hook);
+      }
+      if ("afterSuccess" in hook) {
+        this.registerAfterSuccessHook(hook);
+      }
+      if ("afterError" in hook) {
+        this.registerAfterErrorHook(hook);
+      }
+    }
+    initHooks(this);
+  }
+
+  registerSDKInitHook(hook: SDKInitHook) {
+    this.sdkInitHooks.push(hook);
+  }
+
+  registerBeforeCreateRequestHook(hook: BeforeCreateRequestHook) {
+    this.beforeCreateRequestHooks.push(hook);
+  }
+
+  registerBeforeRequestHook(hook: BeforeRequestHook) {
+    this.beforeRequestHooks.push(hook);
+  }
+
+  registerAfterSuccessHook(hook: AfterSuccessHook) {
+    this.afterSuccessHooks.push(hook);
+  }
+
+  registerAfterErrorHook(hook: AfterErrorHook) {
+    this.afterErrorHooks.push(hook);
+  }
+
+  sdkInit(opts: SDKOptions): SDKOptions {
+    return this.sdkInitHooks.reduce((opts, hook) => hook.sdkInit(opts), opts);
+  }
+
+  beforeCreateRequest(
+    hookCtx: BeforeCreateRequestContext,
+    input: RequestInput,
+  ): RequestInput {
+    let inp = input;
+
+    for (const hook of this.beforeCreateRequestHooks) {
+      inp = hook.beforeCreateRequest(hookCtx, inp);
+    }
+
+    return inp;
+  }
+
+  async beforeRequest(
+    hookCtx: BeforeRequestContext,
+    request: Request,
+  ): Promise<Request> {
+    let req = request;
+
+    for (const hook of this.beforeRequestHooks) {
+      req = await hook.beforeRequest(hookCtx, req);
+    }
+
+    return req;
+  }
+
+  async afterSuccess(
+    hookCtx: AfterSuccessContext,
+    response: Response,
+  ): Promise<Response> {
+    let res = response;
+
+    for (const hook of this.afterSuccessHooks) {
+      res = await hook.afterSuccess(hookCtx, res);
+    }
+
+    return res;
+  }
+
+  async afterError(
+    hookCtx: AfterErrorContext,
+    response: Response | null,
+    error: unknown,
+  ): Promise<{ response: Response | null; error: unknown }> {
+    let res = response;
+    let err = error;
+
+    for (const hook of this.afterErrorHooks) {
+      const result = await hook.afterError(hookCtx, res, err);
+      res = result.response;
+      err = result.error;
+    }
+
+    return { response: res, error: err };
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,6 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export * from "./hooks.js";
+export * from "./types.js";

package/src/hooks/registration.ts

@@ -0,0 +1,14 @@
+import { Hooks } from "./types.js";
+
+/*
+ * This file is only ever generated once on the first generation and then is free to be modified.
+ * Any hooks you wish to add should be registered in the initHooks function. Feel free to define them
+ * in this file or in separate files in the hooks folder.
+ */
+
+// @ts-expect-error remove this line when you add your first hook and hooks is used
+export function initHooks(hooks: Hooks) {
+  // Add hooks by calling hooks.register{ClientInit/BeforeCreateRequest/BeforeRequest/AfterSuccess/AfterError}Hook
+  // with an instance of a hook that implements that specific Hook interface
+  // Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance
+}