@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.10

package/src/VectorSearch.ts

@@ -0,0 +1,75 @@
+import type {
+  Expand,
+  GenericActionCtx,
+  NamedTableInfo,
+  VectorIndexNames,
+  VectorSearchQuery,
+} from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as DataModel from "./DataModel.js";
+
+type ConvexVectorSearch<DataModel_ extends DataModel.AnyWithProps> =
+  GenericActionCtx<DataModel.ToConvex<DataModel_>>["vectorSearch"];
+
+/**
+ * The service shape backing the `VectorSearch` tag. Named so declaration emit
+ * references it instead of expanding the call signature at every usage.
+ */
+export interface VectorSearchService<
+  DataModel_ extends DataModel.AnyWithProps,
+> {
+  <
+    TableName extends DataModel.TableNames<DataModel_>,
+    IndexName extends VectorIndexNames<
+      NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>
+    >,
+  >(
+    tableName: TableName,
+    indexName: IndexName,
+    query: Expand<
+      VectorSearchQuery<
+        NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>,
+        IndexName
+      >
+    >,
+  ): Effect.Effect<
+    Array<{ _id: DataModel.Id<DataModel_, TableName>; _score: number }>
+  >;
+}
+
+export type VectorSearchTag<DataModel_ extends DataModel.AnyWithProps> =
+  Context.Service<
+    VectorSearchService<DataModel_>,
+    VectorSearchService<DataModel_>
+  >;
+
+export const make =
+  <DataModel_ extends DataModel.AnyWithProps>(
+    vectorSearch: ConvexVectorSearch<DataModel_>,
+  ): VectorSearchService<DataModel_> =>
+  (tableName, indexName, query) =>
+    Effect.promise(() => vectorSearch(tableName, indexName, query)).pipe(
+      Effect.map(
+        (rows) =>
+          rows as unknown as Array<{
+            _id: DataModel.Id<DataModel_, typeof tableName>;
+            _score: number;
+          }>,
+      ),
+    );
+
+export const VectorSearch = <
+  DataModel_ extends DataModel.AnyWithProps,
+>(): VectorSearchTag<DataModel_> =>
+  Context.Service<VectorSearchService<DataModel_>>(
+    "@confect/server/VectorSearch",
+  );
+
+export type VectorSearch<DataModel_ extends DataModel.AnyWithProps> =
+  VectorSearchService<DataModel_>;
+
+export const layer = <DataModel_ extends DataModel.AnyWithProps>(
+  vectorSearch: ConvexVectorSearch<DataModel_>,
+) => Layer.succeed(VectorSearch<DataModel_>(), make(vectorSearch));

package/src/index.ts

@@ -0,0 +1,87 @@
+export * as AiGatewayDecisionClient from "./AiGatewayDecisionClient.js";
+export * as AiGatewayDecisionModel from "./AiGatewayDecisionModel.js";
+export * as AiGatewayLanguageClient from "./AiGatewayLanguageClient.js";
+export * as AiGatewayLanguageModel from "./AiGatewayLanguageModel.js";
+export * as ActionCtx from "./ActionCtx.js";
+export * as ActionRunner from "./ActionRunner.js";
+export * as Auth from "./Auth.js";
+export * as BlobNotFoundError from "./BlobNotFoundError.js";
+export * as Callback from "./Callback.js";
+export * as ConvexConfigProvider from "./ConvexConfigProvider.js";
+export * as ConvexFunctionDefinitions from "./ConvexFunctionDefinitions.js";
+export * as ConvexLogger from "./ConvexLogger.js";
+export * as CronJob from "./CronJob.js";
+export * as CronJobs from "./CronJobs.js";
+export * as DatabaseReader from "./DatabaseReader.js";
+export * as DatabaseSchema from "./DatabaseSchema.js";
+export * as DatabaseWriter from "./DatabaseWriter.js";
+export * as DataModel from "./DataModel.js";
+export * as Document from "./Document.js";
+export * as ExecutionMetadata from "./ExecutionMetadata.js";
+export * as FunctionImpl from "./FunctionImpl.js";
+export * as FunctionRegistryItem from "./FunctionRegistryItem.js";
+export * as GroupImpl from "./GroupImpl.js";
+export * as Handler from "./Handler.js";
+export * as HttpRouter from "./HttpRouter.js";
+export * as MiddlewareImpl from "./MiddlewareImpl.js";
+export * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+export * as MutationCtx from "./MutationCtx.js";
+export * as MutationRunner from "./MutationRunner.js";
+export * as MutationTransactionContext from "./MutationTransactionContext.js";
+export * as OrderedQuery from "./OrderedQuery.js";
+export * as QueryCtx from "./QueryCtx.js";
+export * as QueryInitializer from "./QueryInitializer.js";
+export * as QueryRunner from "./QueryRunner.js";
+export * as QueryTransactionContext from "./QueryTransactionContext.js";
+/**
+ * @experimental
+ */
+export * as QueryStream from "./QueryStream.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamCursor from "./QueryStreamCursor.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyLabels from "./QueryStreamKeyLabels.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyBounds from "./QueryStreamKeyBounds.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamIndexRange from "./QueryStreamIndexRange.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamReadBudget from "./QueryStreamReadBudget.js";
+export * as RegisteredConvexFunction from "./RegisteredConvexFunction.js";
+export * as RegisteredFunction from "./RegisteredFunction.js";
+export * as RegisteredFunctions from "./RegisteredFunctions.js";
+export * as Registry from "./Registry.js";
+export * as RegistryItems from "./RegistryItems.js";
+export * as ResolvedMiddleware from "./ResolvedMiddleware.js";
+export * as RequestMetadata from "./RequestMetadata.js";
+export * as Scheduler from "./Scheduler.js";
+export * as Storage from "./Storage.js";
+export * as StorageActionWriter from "./StorageActionWriter.js";
+export * as StorageReader from "./StorageReader.js";
+export * as StorageWriter from "./StorageWriter.js";
+export * as Table from "./Table.js";
+export * as TableInfo from "./TableInfo.js";
+export * as TransactionMetadata from "./TransactionMetadata.js";
+export * as VectorSearch from "./VectorSearch.js";

package/src/internal/AiGatewayDecisionClient.ts

@@ -0,0 +1,16 @@
+import * as OpenRouterClient from "@effect/ai-openrouter/OpenRouterClient";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as AiGatewayServiceToken from "./AiGatewayServiceToken.js";
+import { AI_GATEWAY_API_URL } from "./constants.js";
+
+export const make = Effect.gen(function* () {
+  const serviceToken = yield* AiGatewayServiceToken.AiGatewayServiceToken;
+  yield* serviceToken.get("ai-gateway");
+  return yield* OpenRouterClient.make({
+    apiUrl: AI_GATEWAY_API_URL,
+    transformClient: AiGatewayServiceToken.transformClientRequest(serviceToken),
+  });
+});
+
+export const layer = Layer.effect(OpenRouterClient.OpenRouterClient, make);

package/src/internal/AiGatewayLanguageClient.ts

@@ -0,0 +1,16 @@
+import * as OpenAiClient from "@effect/ai-openai-compat/OpenAiClient";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as AiGatewayServiceToken from "./AiGatewayServiceToken.js";
+import { AI_GATEWAY_API_URL } from "./constants.js";
+
+export const make = Effect.gen(function* () {
+  const serviceToken = yield* AiGatewayServiceToken.AiGatewayServiceToken;
+  yield* serviceToken.get("ai-gateway");
+  return yield* OpenAiClient.make({
+    apiUrl: AI_GATEWAY_API_URL,
+    transformClient: AiGatewayServiceToken.transformClientRequest(serviceToken),
+  });
+});
+
+export const layer = Layer.effect(OpenAiClient.OpenAiClient, make);

package/src/internal/AiGatewayServiceToken.ts

@@ -0,0 +1,129 @@
+import { getServiceToken as getConvexServiceToken } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientError from "effect/http/HttpClientError";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+
+/**
+ * The current team is on the free plan or has the Convex AI gateway disabled.
+ * Upgrade to a paid plan, or contact Convex support if this looks wrong.
+ */
+export class AiGatewayDisabled extends Schema.TaggedError<AiGatewayDisabled>()(
+  "AiGatewayDisabled",
+  {},
+) {
+  override get message(): string {
+    return "The Convex AI gateway is disabled. Your team may be on the free plan, or the gateway may have been disabled for your team. Upgrade to a paid plan, or email support@convex.dev if this looks wrong.";
+  }
+}
+
+/**
+ * The current deployment is anonymous, outdated, or self-hosted and cannot use
+ * the Convex AI gateway. Authenticated, project-linked local deployments are
+ * supported.
+ */
+export class AiGatewayUnavailable extends Schema.TaggedError<AiGatewayUnavailable>()(
+  "AiGatewayUnavailable",
+  {},
+) {
+  override get message(): string {
+    return "The Convex AI gateway is unavailable on this deployment. For local development, log in, link the deployment to a Convex project, and update the Convex CLI and local backend. Anonymous and self-hosted deployments cannot use the gateway; call the model provider directly with your own API key instead.";
+  }
+}
+
+/**
+ * A schema for the possible failures that can occur while obtaining a Convex AI
+ * gateway service token.
+ */
+export const AiGatewayError = Schema.Union([
+  AiGatewayDisabled,
+  AiGatewayUnavailable,
+]);
+
+/**
+ * The possible failures that can occur while obtaining a Convex AI gateway
+ * service token.
+ */
+export type AiGatewayError = typeof AiGatewayError.Type;
+
+type GetServiceToken = typeof getConvexServiceToken;
+type AiGatewayErrorCode = AiGatewayError["_tag"];
+
+const nodeRuntimeErrorCodeFragments: Record<AiGatewayErrorCode, string> = {
+  AiGatewayDisabled: '"code":"AiGatewayDisabled"',
+  AiGatewayUnavailable: '"code":"AiGatewayUnavailable"',
+};
+
+// The default Convex runtime exposes only the human-readable ErrorMetadata
+// message. Node actions preserve the short code in a wrapped JSON response.
+const defaultRuntimeErrorMessagePrefixes: Record<AiGatewayErrorCode, string> = {
+  AiGatewayDisabled: "The Convex AI gateway is not enabled for your team.",
+  AiGatewayUnavailable:
+    '`getServiceToken("ai-gateway")` isn\'t available on this deployment',
+};
+
+export interface Service {
+  readonly get: (
+    service: "ai-gateway",
+  ) => Effect.Effect<string, AiGatewayError>;
+}
+
+export class AiGatewayServiceToken extends Context.Service<
+  AiGatewayServiceToken,
+  Service
+>()("@confect/server/internal/AiGatewayServiceToken") {}
+
+const matchesErrorCode = (
+  rejection: unknown,
+  code: AiGatewayErrorCode,
+): boolean =>
+  (typeof rejection === "object" &&
+    rejection !== null &&
+    "code" in rejection &&
+    rejection.code === code) ||
+  (rejection instanceof Error &&
+    (rejection.message.includes(nodeRuntimeErrorCodeFragments[code]) ||
+      rejection.message.includes(defaultRuntimeErrorMessagePrefixes[code])));
+
+const classifyError = (rejection: unknown): AiGatewayError => {
+  if (matchesErrorCode(rejection, "AiGatewayDisabled")) {
+    return new AiGatewayDisabled();
+  }
+  if (matchesErrorCode(rejection, "AiGatewayUnavailable")) {
+    return new AiGatewayUnavailable();
+  }
+  throw rejection;
+};
+
+export const make = (getServiceToken: GetServiceToken): Service => ({
+  get: (service) =>
+    Effect.tryPromise({
+      try: () => getServiceToken(service),
+      catch: classifyError,
+    }),
+});
+
+export const layer = Layer.succeed(
+  AiGatewayServiceToken,
+  make(getConvexServiceToken),
+);
+
+export const transformClientRequest = (serviceToken: Service) =>
+  HttpClient.mapRequestEffect((request) =>
+    serviceToken.get("ai-gateway").pipe(
+      Effect.map((token) => HttpClientRequest.bearerToken(request, token)),
+      Effect.mapError(
+        (cause) =>
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.TransportError({
+              request,
+              cause,
+              description: cause.message,
+            }),
+          }),
+      ),
+    ),
+  );

package/src/internal/constants.ts

@@ -0,0 +1 @@
+export const AI_GATEWAY_API_URL = "https://ai-gateway.convex.dev/v1";

package/src/internal/utils.ts

@@ -0,0 +1,89 @@
+import type { Predicate } from "effect";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
+
+type NestedObject<T> = {
+  [key: string]: T | NestedObject<T>;
+};
+
+export const mapLeaves = <T, U>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  f: (value: T) => U,
+): NestedObject<U> => {
+  const result: any = {};
+
+  for (const key in obj) {
+    const value = obj[key];
+
+    if (leafRefinement(value)) {
+      result[key] = f(value as T);
+    } else {
+      result[key] = mapLeaves(value as NestedObject<T>, leafRefinement, f);
+    }
+  }
+
+  return result;
+};
+
+const collectBranchLeaves = <T>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  path: string[] = [],
+): { path: string[]; values: Record<string, T> }[] => {
+  const leaves = Record.filter(obj, leafRefinement) as Record<string, T>;
+  const hasLeaves = Record.keys(leaves).length > 0;
+
+  const currentBranch = hasLeaves ? [{ path, values: leaves }] : [];
+
+  const nestedBranches = Array.flatMap(Record.keys(obj), (key) => {
+    const value = obj[key];
+
+    if (!leafRefinement(value) && typeof value === "object") {
+      return collectBranchLeaves(value as NestedObject<T>, leafRefinement, [
+        ...path,
+        key,
+      ]);
+    }
+    return [];
+  });
+
+  return [...currentBranch, ...nestedBranches];
+};
+
+export const forEachBranchLeaves = <T, A, E, R>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  f: (branchLeaves: {
+    path: string[];
+    values: Record<string, T>;
+  }) => Effect.Effect<A, E, R>,
+): Effect.Effect<void, E, R> => {
+  const branchLeaves = collectBranchLeaves(obj, leafRefinement);
+  return Effect.forEach(branchLeaves, f, {
+    discard: true,
+  });
+};
+
+export const setNestedProperty = <T extends object>(
+  obj: T,
+  path: PropertyKey[],
+  value: any,
+): T => {
+  if (path.length === 0) {
+    return obj;
+  }
+
+  if (path.length === 1) {
+    const key = path[0] as keyof T;
+    return { ...obj, [key]: value };
+  }
+
+  const [head, ...tail] = path;
+  const key = head as keyof T;
+  return {
+    ...obj,
+    [key]: setNestedProperty((obj as any)[key] ?? {}, tail, value),
+  };
+};

package/src/node.ts

@@ -0,0 +1 @@
+export * as RegisteredNodeFunction from "./RegisteredNodeFunction.js";