@functional-systems/lambdadb 0.4.2 → 0.5.0-rc.1

package/src/compat/qdrant/client.ts

@@ -1,6 +1,10 @@
 import { LambdaDBClient, type LambdaDBClientOptions } from "../../client.js";
 import { ResourceNotFoundError } from "../../models/errors/index.js";
-import type { CreateCollectionInput } from "../../types/public.js";
+import type {
+  CreateCollectionInput,
+  ListDocsInput,
+  UpdateCollectionInput,
+} from "../../types/public.js";
 import {
   ORIGINAL_ID_FIELD,
   mergeIndexConfigs,
@@ -24,17 +28,18 @@ import {
 } from "./errors.js";
 
 type JsonObject = { [key: string]: unknown };
+type ListDocsBody = ListDocsInput;
 
 type CollectionLike = {
   get(): Promise<{ collection: JsonObject }>;
-  update(body: { indexConfigs: IndexConfigs }): Promise<unknown>;
+  update(body: UpdateCollectionInput): Promise<unknown>;
   delete(): Promise<unknown>;
   query(body: JsonObject): Promise<{ docs: unknown[] }>;
   docs: {
     upsert(body: { docs: JsonObject[] }): Promise<unknown>;
     fetch(body: JsonObject): Promise<{ docs: unknown[] }>;
     delete(body: { ids?: string[]; filter?: JsonObject }): Promise<unknown>;
-    list(body?: { size?: number; pageToken?: string }): Promise<{
+    list(body?: ListDocsBody): Promise<{
       docs: unknown[];
       nextPageToken?: string | undefined;
     }>;
@@ -183,7 +188,7 @@ export class QdrantCompatClient {
       collectionName,
       indexConfigs: indexConfigs as CreateCollectionInput["indexConfigs"],
     });
-    await this.waitForCollectionActive(collectionName, body.timeout);
+    await this.waitForCollectionAvailable(collectionName, body.timeout);
     return true;
   }
 
@@ -254,9 +259,12 @@ export class QdrantCompatClient {
     }
 
     await this.client.collection(collectionName).update({
-      indexConfigs: mergeIndexConfigs(existingIndexConfigs, payloadIndexConfig),
+      indexConfigs: mergeIndexConfigs(
+        existingIndexConfigs,
+        payloadIndexConfig,
+      ) as UpdateCollectionInput["indexConfigs"],
     });
-    await this.waitForCollectionActive(collectionName, timeout);
+    await this.waitForCollectionAvailable(collectionName, timeout);
     return true;
   }
 
@@ -615,6 +623,7 @@ export class QdrantCompatClient {
     options: {
       scrollFilter?: models.Filter | JsonObject | null;
       scroll_filter?: models.Filter | JsonObject | null;
+      offset?: string | number | undefined;
       limit?: number | undefined;
       withPayload?: PayloadSelector | undefined;
       with_payload?: PayloadSelector | undefined;
@@ -626,6 +635,7 @@ export class QdrantCompatClient {
     const {
       scrollFilter,
       scroll_filter: scrollFilterSnake,
+      offset,
       limit = 10,
       withPayload,
       with_payload: withPayloadSnake,
@@ -634,12 +644,23 @@ export class QdrantCompatClient {
       ...rest
     } = options;
     warnIgnored(rest);
-    if (scrollFilter !== undefined || scrollFilterSnake !== undefined) {
-      throw new UnsupportedQdrantFeatureError("Filtered scroll is not supported in v1");
+    if (offset !== undefined && typeof offset !== "string") {
+      throw new UnsupportedQdrantFeatureError(
+        "Qdrant point-id scroll offsets are not supported; use the returned LambdaDB page-token offset",
+      );
     }
     const payloadSelector = normalizePayloadSelector(withPayload ?? withPayloadSnake ?? true);
     const vectorSelector = normalizeVectorSelector(withVectors ?? withVectorsSnake ?? false);
-    const response = await this.client.collection(collectionName).docs.list({ size: limit });
+    const fields = fieldsForSelectors(payloadSelector, vectorSelector);
+    const convertedFilter = filterToLambdaDB(scrollFilter ?? scrollFilterSnake);
+    const listBody: ListDocsBody = {
+      size: limit,
+      includeVectors: vectorSelector !== false,
+    };
+    if (offset !== undefined) listBody.pageToken = offset;
+    if (Object.keys(convertedFilter).length > 0) listBody.filter = convertedFilter;
+    if (fields !== undefined) listBody.fields = fields;
+    const response = await this.client.collection(collectionName).docs.list(listBody);
     return [
       response.docs.map((doc) => docToRecord(doc, {
         withPayload: payloadSelector,
@@ -676,24 +697,25 @@ export class QdrantCompatClient {
     return response.collection;
   }
 
-  private async waitForCollectionActive(
+  private async waitForCollectionAvailable(
     collectionName: string,
     timeoutSeconds: unknown,
   ): Promise<void> {
     const timeout = typeof timeoutSeconds === "number" ? timeoutSeconds : 60;
     const deadline = Date.now() + timeout * 1000;
-    let lastStatus = "unknown";
     while (true) {
-      const collection = await this.currentCollection(collectionName);
-      const status = collection["collectionStatus"];
-      if (status === undefined || status === "ACTIVE") return;
-      lastStatus = String(status);
-      if (Date.now() >= deadline) {
-        throw new QdrantCompatError(
-          `Collection ${collectionName} did not become ACTIVE within ${timeout}s; last status=${lastStatus}`,
-        );
+      try {
+        await this.currentCollection(collectionName);
+        return;
+      } catch (error) {
+        if (!isNotFoundError(error)) throw error;
+        if (Date.now() >= deadline) {
+          throw new QdrantCompatError(
+            `Collection ${collectionName} was not available within ${timeout}s`,
+          );
+        }
+        await sleep(500);
       }
-      await sleep(500);
     }
   }
 }
@@ -723,6 +745,7 @@ function normalizeConstructorOptions(
     "timeoutMs",
     "retryConfig",
     "httpClient",
+    "transferClient",
     "serverURL",
     "projectHost",
     "path",
@@ -765,6 +788,9 @@ function normalizeConstructorOptions(
   if (timeoutMs !== undefined) normalized.timeoutMs = timeoutMs;
   if (options.retryConfig !== undefined) normalized.retryConfig = options.retryConfig;
   if (options.httpClient !== undefined) normalized.httpClient = options.httpClient;
+  if (options.transferClient !== undefined) {
+    normalized.transferClient = options.transferClient;
+  }
   if (options.serverURL !== undefined) normalized.serverURL = options.serverURL;
   if (options.projectHost !== undefined) normalized.projectHost = options.projectHost;
   return normalized;

package/src/compat/qdrant/filters.ts

@@ -92,9 +92,11 @@ function matchQueries(field: string, rawMatch: unknown): LambdaDBQuery[] {
     return match.except.map((value) => queryString(`${field}:${formatScalar(value)}`));
   }
   if (match instanceof MatchText) {
-    throw new UnsupportedQdrantFeatureError(
-      "MatchText is not supported in the v1 Qdrant compatibility filter",
-    );
+    const terms = match.text.split(/\s+/).filter(Boolean);
+    if (terms.length === 0) {
+      throw new QdrantCompatValidationError("MatchText text must not be empty");
+    }
+    return terms.map((term) => queryString(`${field}:${formatScalar(term)}`));
   }
 
   throw new UnsupportedQdrantFeatureError(

package/src/funcs/collectionsCreate.ts

@@ -175,7 +175,7 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(202, operations.CreateCollectionResponse$inboundSchema),
+    M.json(201, operations.CreateCollectionResponse$inboundSchema),
     M.jsonErr(400, errors.BadRequestError$inboundSchema),
     M.jsonErr(401, errors.UnauthenticatedError$inboundSchema),
     M.jsonErr(409, errors.ResourceAlreadyExistsError$inboundSchema),

package/src/funcs/collectionsDelete.ts

@@ -179,7 +179,7 @@ async function $do(
     | UnexpectedClientError
     | SDKValidationError
   >(
-    M.json(202, models.MessageResponse$inboundSchema),
+    M.json(200, models.MessageResponse$inboundSchema),
     M.jsonErr(401, errors.UnauthenticatedError$inboundSchema),
     M.jsonErr(404, errors.ResourceNotFoundError$inboundSchema),
     M.jsonErr(429, errors.TooManyRequestsError$inboundSchema),

package/src/funcs/collectionsDocsGetBulkUpsert.ts

@@ -3,7 +3,7 @@
  */
 
 import { LambdaDBCore } from "../core.js";
-import { encodeSimple } from "../lib/encodings.js";
+import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
@@ -104,6 +104,10 @@ async function $do(
     pathParams,
   );
 
+  const query = encodeFormQuery({
+    "branch": payload.branch,
+  });
+
   const headers = new Headers(compactMap({
     Accept: "application/json",
   }));
@@ -142,6 +146,7 @@ async function $do(
     method: "GET",
     baseURL: options?.serverURL,
     path: path,
+    query: query,
     headers: headers,
     body: body,
     userAgent: client._options.userAgent,

package/src/funcs/collectionsDocsListDocs.ts

@@ -103,7 +103,10 @@ async function $do(
   const path = pathToFunc("/collections/{collectionName}/docs")(pathParams);
 
   const query = encodeFormQuery({
+    "includeVectors": payload.includeVectors,
     "pageToken": payload.pageToken,
+    "refKind": payload.refKind,
+    "refName": payload.refName,
     "size": payload.size,
   });
 

package/src/funcs/collectionsDocsListDocsExtended.ts

@@ -0,0 +1,201 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { LambdaDBCore } from "../core.js";
+import { encodeJSON, encodeSimple } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { LambdaDBError } from "../models/errors/lambdadberror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+/**
+ * List documents in a collection with optional filters, field selection, and vector inclusion.
+ */
+export function collectionsDocsListDocsExtended(
+  client: LambdaDBCore,
+  request: operations.ListDocsExtendedRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.ListDocsResponse,
+    | errors.BadRequestError
+    | errors.UnauthenticatedError
+    | errors.ResourceNotFoundError
+    | errors.TooManyRequestsError
+    | errors.InternalServerError
+    | LambdaDBError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: LambdaDBCore,
+  request: operations.ListDocsExtendedRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.ListDocsResponse,
+      | errors.BadRequestError
+      | errors.UnauthenticatedError
+      | errors.ResourceNotFoundError
+      | errors.TooManyRequestsError
+      | errors.InternalServerError
+      | LambdaDBError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.ListDocsExtendedRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
+
+  const pathParams = {
+    collectionName: encodeSimple("collectionName", payload.collectionName, {
+      explode: false,
+      charEncoding: "percent",
+    }),
+  };
+
+  const path = pathToFunc("/collections/{collectionName}/docs/list")(
+    pathParams,
+  );
+
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.projectApiKey);
+  const securityInput = secConfig == null ? {} : { projectApiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listDocsExtended",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.projectApiKey,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 60000,
+          exponent: 1.5,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "5XX"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    body: body,
+    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: ["400", "401", "404", "429", "4XX", "500", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.ListDocsResponse,
+    | errors.BadRequestError
+    | errors.UnauthenticatedError
+    | errors.ResourceNotFoundError
+    | errors.TooManyRequestsError
+    | errors.InternalServerError
+    | LambdaDBError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.ListDocsResponse$inboundSchema),
+    M.jsonErr(400, errors.BadRequestError$inboundSchema),
+    M.jsonErr(401, errors.UnauthenticatedError$inboundSchema),
+    M.jsonErr(404, errors.ResourceNotFoundError$inboundSchema),
+    M.jsonErr(429, errors.TooManyRequestsError$inboundSchema),
+    M.jsonErr(500, errors.InternalServerError$inboundSchema),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/index.ts

@@ -12,12 +12,29 @@ export * from "./sdk/sdk.js";
 export {
   LambdaDBClient,
   CollectionHandle,
+  CollectionDocs,
   DEFAULT_BASE_URL,
   DEFAULT_PROJECT_NAME,
   type RequestOptions as ClientRequestOptions,
   type LambdaDBClientOptions,
 } from "./client.js";
 
+/** Data Versioning lifecycle clients and validated ref/source/target helpers. */
+export {
+  CollectionAliases,
+  CollectionBranches,
+  CollectionTags,
+  DATA_VERSIONING_CONTRACT_REVISION,
+  aliasRef,
+  branchRef,
+  branchSource,
+  branchTarget,
+  tagRef,
+  tagSource,
+  tagTarget,
+} from "./versioning.js";
+export type { VersioningError } from "./versioning.js";
+
 /** Public API types (inputs and responses for the collection-scoped client). */
 export type * from "./types/public.js";
 

package/src/lib/config.ts

@@ -73,8 +73,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.1.1",
-  sdkVersion: "0.2.1",
+  sdkVersion: "0.5.0-rc.1",
   genVersion: "2.798.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.2.1 2.798.0 1.1.1 @functional-systems/lambdadb",
+    "speakeasy-sdk/typescript 0.5.0-rc.1 2.798.0 1.1.1 @functional-systems/lambdadb",
 } as const;

package/src/lib/queryInput.ts

@@ -2,20 +2,13 @@
  * Helper to build QueryCollectionInput for collection.query() / collection.querySafe().
  */
 
-import type { FieldsSelectorUnion, PartitionFilter } from "../models/index.js";
 import type { QueryCollectionInput } from "../types/public.js";
 
 /**
  * Options for createQueryInput (all optional except query).
  */
-export type CreateQueryInputOptions = {
-  size?: number;
-  consistentRead?: boolean;
-  includeVectors?: boolean;
-  sort?: Array<{ [k: string]: unknown }>;
-  fields?: FieldsSelectorUnion;
-  partitionFilter?: PartitionFilter;
-};
+type WithoutQuery<T> = T extends unknown ? Omit<T, "query"> : never;
+export type CreateQueryInputOptions = WithoutQuery<QueryCollectionInput>;
 
 /**
  * Build a query input object for collection.query() or collection.querySafe().
@@ -29,5 +22,5 @@ export function createQueryInput(
   query: { [k: string]: unknown },
   options?: CreateQueryInputOptions,
 ): QueryCollectionInput {
-  return { query, ...options };
+  return { query, ...options } as QueryCollectionInput;
 }

package/src/models/collectionresponse.ts

@@ -14,7 +14,6 @@ import {
   PartitionConfig,
   PartitionConfig$inboundSchema,
 } from "./partitionconfig.js";
-import { Status, Status$inboundSchema } from "./status.js";
 
 export type CollectionResponse = {
   /**
@@ -26,6 +25,10 @@ export type CollectionResponse = {
    */
   collectionName: string;
   indexConfigs: { [k: string]: IndexConfigsUnion };
+  /** Collection description. */
+  description: string;
+  /** Collection metadata tags. */
+  tags: Record<string, string>;
   partitionConfig?: PartitionConfig | undefined;
   /**
    * Total number of partitions including the default partition.
@@ -35,34 +38,22 @@ export type CollectionResponse = {
    * Total number of documents.
    */
   numDocs: number;
+  /** Default writable Branch. */
+  defaultBranchName: "main";
+  /** Number of days that committed snapshots are retained. */
+  snapshotRetentionInDays: number;
   /**
-   * Source project name.
-   */
-  sourceProjectName?: string | undefined;
-  /**
-   * Source collection name.
-   */
-  sourceCollectionName?: string | undefined;
-  /**
-   * Source collection version.
-   */
-  sourceCollectionVersionId?: string | undefined;
-  /**
-   * Status
-   */
-  collectionStatus: Status;
-  /**
-   * Collection creation time in seconds since the Unix epoch.
+   * Collection creation time in milliseconds since the Unix epoch.
    */
   createdAt: number;
   /**
-   * Collection last update time in seconds since the Unix epoch.
+   * Collection last update time in milliseconds since the Unix epoch.
    */
   updatedAt: number;
   /**
-   * Collection data last update time in seconds since the Unix epoch.
+   * Collection data last update time in milliseconds since the Unix epoch.
    */
-  dataUpdatedAt: number;
+  dataUpdatedAt?: number | undefined;
 };
 
 /** @internal */
@@ -74,16 +65,16 @@ export const CollectionResponse$inboundSchema: z.ZodType<
   projectName: z.string(),
   collectionName: z.string(),
   indexConfigs: z.record(IndexConfigsUnion$inboundSchema),
+  description: z.string(),
+  tags: z.record(z.string()),
   partitionConfig: nullToUndefined(PartitionConfig$inboundSchema.optional()),
   numPartitions: z.number().int(),
   numDocs: z.number().int(),
-  sourceProjectName: nullToUndefined(z.string().optional()),
-  sourceCollectionName: nullToUndefined(z.string().optional()),
-  sourceCollectionVersionId: nullToUndefined(z.string().optional()),
-  collectionStatus: Status$inboundSchema,
+  defaultBranchName: z.literal("main"),
+  snapshotRetentionInDays: z.number().int().min(1).max(31),
   createdAt: z.number().int(),
   updatedAt: z.number().int(),
-  dataUpdatedAt: z.number().int(),
+  dataUpdatedAt: nullToUndefined(z.number().int().optional()),
 });
 
 export function collectionResponseFromJSON(

package/src/models/index.ts

@@ -10,3 +10,4 @@ export * from "./partitionconfig.js";
 export * from "./partitionfilter.js";
 export * from "./security.js";
 export * from "./status.js";
+export * from "./versioning.js";

package/src/models/operations/bulkupsertdocs.ts

@@ -10,6 +10,10 @@ export type BulkUpsertDocsRequestBody = {
    * Object key uploaded based on bulk upsert info.
    */
   objectKey: string;
+  /** Content type supplied by the bulk-upload info response. */
+  type?: "application/json" | undefined;
+  /** Write target Branch. Must match the bulk-upload info request. */
+  branch?: string | undefined;
 };
 
 export type BulkUpsertDocsRequest = {
@@ -23,6 +27,8 @@ export type BulkUpsertDocsRequest = {
 /** @internal */
 export type BulkUpsertDocsRequestBody$Outbound = {
   objectKey: string;
+  type: "application/json";
+  branch?: string | undefined;
 };
 
 /** @internal */
@@ -32,6 +38,8 @@ export const BulkUpsertDocsRequestBody$outboundSchema: z.ZodType<
   BulkUpsertDocsRequestBody
 > = z.object({
   objectKey: z.string(),
+  type: z.literal("application/json").default("application/json"),
+  branch: z.string().regex(/^[a-zA-Z0-9_-]{3,52}$/).optional(),
 });
 
 export function bulkUpsertDocsRequestBodyToJSON(