@functional-systems/lambdadb 0.1.3

package/src/models/operations/upsertdocs.ts

@@ -0,0 +1,143 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type UpsertDocsRequestBody = {
+  /**
+   * A list of documents to upsert.
+   */
+  docs: Array<{ [k: string]: any }>;
+};
+
+export type UpsertDocsRequest = {
+  /**
+   * Collection name.
+   */
+  collectionName: string;
+  requestBody: UpsertDocsRequestBody;
+};
+
+/** @internal */
+export const UpsertDocsRequestBody$inboundSchema: z.ZodType<
+  UpsertDocsRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  docs: z.array(z.record(z.any())),
+});
+
+/** @internal */
+export type UpsertDocsRequestBody$Outbound = {
+  docs: Array<{ [k: string]: any }>;
+};
+
+/** @internal */
+export const UpsertDocsRequestBody$outboundSchema: z.ZodType<
+  UpsertDocsRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpsertDocsRequestBody
+> = z.object({
+  docs: z.array(z.record(z.any())),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpsertDocsRequestBody$ {
+  /** @deprecated use `UpsertDocsRequestBody$inboundSchema` instead. */
+  export const inboundSchema = UpsertDocsRequestBody$inboundSchema;
+  /** @deprecated use `UpsertDocsRequestBody$outboundSchema` instead. */
+  export const outboundSchema = UpsertDocsRequestBody$outboundSchema;
+  /** @deprecated use `UpsertDocsRequestBody$Outbound` instead. */
+  export type Outbound = UpsertDocsRequestBody$Outbound;
+}
+
+export function upsertDocsRequestBodyToJSON(
+  upsertDocsRequestBody: UpsertDocsRequestBody,
+): string {
+  return JSON.stringify(
+    UpsertDocsRequestBody$outboundSchema.parse(upsertDocsRequestBody),
+  );
+}
+
+export function upsertDocsRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpsertDocsRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpsertDocsRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpsertDocsRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpsertDocsRequest$inboundSchema: z.ZodType<
+  UpsertDocsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  collectionName: z.string(),
+  RequestBody: z.lazy(() => UpsertDocsRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+
+/** @internal */
+export type UpsertDocsRequest$Outbound = {
+  collectionName: string;
+  RequestBody: UpsertDocsRequestBody$Outbound;
+};
+
+/** @internal */
+export const UpsertDocsRequest$outboundSchema: z.ZodType<
+  UpsertDocsRequest$Outbound,
+  z.ZodTypeDef,
+  UpsertDocsRequest
+> = z.object({
+  collectionName: z.string(),
+  requestBody: z.lazy(() => UpsertDocsRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpsertDocsRequest$ {
+  /** @deprecated use `UpsertDocsRequest$inboundSchema` instead. */
+  export const inboundSchema = UpsertDocsRequest$inboundSchema;
+  /** @deprecated use `UpsertDocsRequest$outboundSchema` instead. */
+  export const outboundSchema = UpsertDocsRequest$outboundSchema;
+  /** @deprecated use `UpsertDocsRequest$Outbound` instead. */
+  export type Outbound = UpsertDocsRequest$Outbound;
+}
+
+export function upsertDocsRequestToJSON(
+  upsertDocsRequest: UpsertDocsRequest,
+): string {
+  return JSON.stringify(
+    UpsertDocsRequest$outboundSchema.parse(upsertDocsRequest),
+  );
+}
+
+export function upsertDocsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpsertDocsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpsertDocsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpsertDocsRequest' from JSON`,
+  );
+}

package/src/models/security.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+
+export type Security = {
+  projectApiKey?: string | undefined;
+};
+
+/** @internal */
+export const Security$inboundSchema: z.ZodType<
+  Security,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ProjectApiKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ProjectApiKey": "projectApiKey",
+  });
+});
+
+/** @internal */
+export type Security$Outbound = {
+  ProjectApiKey?: string | undefined;
+};
+
+/** @internal */
+export const Security$outboundSchema: z.ZodType<
+  Security$Outbound,
+  z.ZodTypeDef,
+  Security
+> = z.object({
+  projectApiKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    projectApiKey: "ProjectApiKey",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Security$ {
+  /** @deprecated use `Security$inboundSchema` instead. */
+  export const inboundSchema = Security$inboundSchema;
+  /** @deprecated use `Security$outboundSchema` instead. */
+  export const outboundSchema = Security$outboundSchema;
+  /** @deprecated use `Security$Outbound` instead. */
+  export type Outbound = Security$Outbound;
+}
+
+export function securityToJSON(security: Security): string {
+  return JSON.stringify(Security$outboundSchema.parse(security));
+}
+
+export function securityFromJSON(
+  jsonString: string,
+): SafeParseResult<Security, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Security$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Security' from JSON`,
+  );
+}

package/src/models/status.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+
+/**
+ * Status
+ */
+export const Status = {
+  Creating: "CREATING",
+  Active: "ACTIVE",
+  Deleting: "DELETING",
+} as const;
+/**
+ * Status
+ */
+export type Status = ClosedEnum<typeof Status>;
+
+/** @internal */
+export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
+  .nativeEnum(Status);
+
+/** @internal */
+export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
+  Status$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Status$ {
+  /** @deprecated use `Status$inboundSchema` instead. */
+  export const inboundSchema = Status$inboundSchema;
+  /** @deprecated use `Status$outboundSchema` instead. */
+  export const outboundSchema = Status$outboundSchema;
+}

package/src/sdk/collections.ts

@@ -0,0 +1,104 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { collectionsCreate } from "../funcs/collectionsCreate.js";
+import { collectionsDelete } from "../funcs/collectionsDelete.js";
+import { collectionsGet } from "../funcs/collectionsGet.js";
+import { collectionsList } from "../funcs/collectionsList.js";
+import { collectionsQuery } from "../funcs/collectionsQuery.js";
+import { collectionsUpdate } from "../funcs/collectionsUpdate.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { Docs } from "./docs.js";
+
+export class Collections extends ClientSDK {
+  private _docs?: Docs;
+  get docs(): Docs {
+    return (this._docs ??= new Docs(this._options));
+  }
+
+  /**
+   * List all collections in an existing project.
+   */
+  async list(
+    options?: RequestOptions,
+  ): Promise<operations.ListCollectionsResponse> {
+    return unwrapAsync(collectionsList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create a collection.
+   */
+  async create(
+    request: operations.CreateCollectionRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateCollectionResponse> {
+    return unwrapAsync(collectionsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete an existing collection.
+   */
+  async delete(
+    request: operations.DeleteCollectionRequest,
+    options?: RequestOptions,
+  ): Promise<models.MessageResponse> {
+    return unwrapAsync(collectionsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get metadata of an existing collection.
+   */
+  async get(
+    request: operations.GetCollectionRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetCollectionResponse> {
+    return unwrapAsync(collectionsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Configure a collection.
+   */
+  async update(
+    request: operations.UpdateCollectionRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateCollectionResponse> {
+    return unwrapAsync(collectionsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search a collection with a query and return the most similar documents.
+   */
+  async query(
+    request: operations.QueryCollectionRequest,
+    options?: RequestOptions,
+  ): Promise<operations.QueryCollectionResponse> {
+    return unwrapAsync(collectionsQuery(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/docs.ts

@@ -0,0 +1,100 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { collectionsDocsBulkUpsert } from "../funcs/collectionsDocsBulkUpsert.js";
+import { collectionsDocsDelete } from "../funcs/collectionsDocsDelete.js";
+import { collectionsDocsFetch } from "../funcs/collectionsDocsFetch.js";
+import { collectionsDocsGetBulkUpsert } from "../funcs/collectionsDocsGetBulkUpsert.js";
+import { collectionsDocsUpdate } from "../funcs/collectionsDocsUpdate.js";
+import { collectionsDocsUpsert } from "../funcs/collectionsDocsUpsert.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Docs extends ClientSDK {
+  /**
+   * Upsert documents into a collection. Note that the maximum supported payload size is 6MB.
+   */
+  async upsert(
+    request: operations.UpsertDocsRequest,
+    options?: RequestOptions,
+  ): Promise<models.MessageResponse> {
+    return unwrapAsync(collectionsDocsUpsert(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Request required info to upload documents.
+   */
+  async getBulkUpsert(
+    request: operations.GetBulkUpsertDocsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBulkUpsertDocsResponse> {
+    return unwrapAsync(collectionsDocsGetBulkUpsert(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Bulk upsert documents into a collection. Note that the maximum supported object size is 200MB.
+   */
+  async bulkUpsert(
+    request: operations.BulkUpsertDocsRequest,
+    options?: RequestOptions,
+  ): Promise<models.MessageResponse> {
+    return unwrapAsync(collectionsDocsBulkUpsert(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update documents in a collection. Note that the maximum supported payload size is 6MB.
+   */
+  async update(
+    request: operations.UpdateDocsRequest,
+    options?: RequestOptions,
+  ): Promise<models.MessageResponse> {
+    return unwrapAsync(collectionsDocsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete documents by document IDs or query filter from a collection.
+   */
+  async delete(
+    request: operations.DeleteDocsRequest,
+    options?: RequestOptions,
+  ): Promise<models.MessageResponse> {
+    return unwrapAsync(collectionsDocsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Lookup and return documents by document IDs from a collection.
+   */
+  async fetch(
+    request: operations.FetchDocsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.FetchDocsResponse> {
+    return unwrapAsync(collectionsDocsFetch(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/index.ts

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

package/src/sdk/sdk.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Collections } from "./collections.js";
+
+export class LambdaDB extends ClientSDK {
+  private _collections?: Collections;
+  get collections(): Collections {
+    return (this._collections ??= new Collections(this._options));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> =
+  z.custom<Blob>(isBlobLike, {
+    message: "expected a Blob, File or Blob-like object",
+    fatal: true,
+  });
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}

package/src/types/constdatetime.ts

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export function constDateTime(
+  val: string,
+): z.ZodType<string, z.ZodTypeDef, unknown> {
+  return z.custom<string>((v) => {
+    return (
+      typeof v === "string" && new Date(v).getTime() === new Date(val).getTime()
+    );
+  }, `Value must be equivalent to ${val}`);
+}

package/src/types/enums.ts

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+declare const __brand: unique symbol;
+export type Unrecognized<T> = T & { [__brand]: "unrecognized" };
+
+export function catchUnrecognizedEnum<T>(value: T): Unrecognized<T> {
+  return value as Unrecognized<T>;
+}
+
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+export type ClosedEnum<T> = T[keyof T];
+export type OpenEnum<T> =
+  | Prettify<T[keyof T]>
+  | Unrecognized<T[keyof T] extends number ? number : string>;

package/src/types/fp.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+/**
+ * A monad that captures the result of a function call or an error if it was not
+ * successful. Railway programming, enabled by this type, can be a nicer
+ * alternative to traditional exception throwing because it allows functions to
+ * declare all _known_ errors with static types and then check for them
+ * exhaustively in application code. Thrown exception have a type of `unknown`
+ * and break out of regular control flow of programs making them harder to
+ * inspect and more verbose work with due to try-catch blocks.
+ */
+export type Result<T, E = unknown> =
+  | { ok: true; value: T; error?: never }
+  | { ok: false; value?: never; error: E };
+
+export function OK<V>(value: V): Result<V, never> {
+  return { ok: true, value };
+}
+
+export function ERR<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+/**
+ * unwrap is a convenience function for extracting a value from a result or
+ * throwing if there was an error.
+ */
+export function unwrap<T>(r: Result<T, unknown>): T {
+  if (!r.ok) {
+    throw r.error;
+  }
+  return r.value;
+}
+
+/**
+ * unwrapAsync is a convenience function for resolving a value from a Promise
+ * of a result or rejecting if an error occurred.
+ */
+export async function unwrapAsync<T>(
+  pr: Promise<Result<T, unknown>>,
+): Promise<T> {
+  const r = await pr;
+  if (!r.ok) {
+    throw r.error;
+  }
+
+  return r.value;
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export { blobLikeSchema, isBlobLike } from "./blobs.js";
+export { catchUnrecognizedEnum } from "./enums.js";
+export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
+export type { Result } from "./fp.js";
+export type { PageIterator, Paginator } from "./operations.js";
+export { createPageIterator } from "./operations.js";
+export { RFCDate } from "./rfcdate.js";