@useairfoil/connector-kit 0.4.0 → 0.5.1

package/src/publisher/service.ts

@@ -1,20 +1,37 @@
+import type * as Wings from "@useairfoil/wings";
 import type * as Effect from "effect/Effect";
 
 import { Context } from "effect";
 
-import type { ConnectorError } from "../core/errors";
-import type { Batch } from "../core/types";
+import type { ResourceBatch } from "../core/types";
+import type { ConnectorError } from "../errors";
 
-export type PublishAck = {
-  readonly success: boolean;
+export type PublishSource = "backfill" | "changes" | "webhook";
+
+export type PublishAck =
+  | {
+      readonly status: "accepted";
+      readonly resource: string;
+      readonly partition?: Wings.PartitionValue.PartitionValue;
+    }
+  | {
+      readonly status: "rejected";
+      readonly resource: string;
+      readonly reason: string;
+      readonly rejectedRows?: number;
+      readonly partition?: Wings.PartitionValue.PartitionValue;
+    };
+
+export type PublishOptions = {
+  readonly resource: string;
+  readonly source: PublishSource;
+  readonly batch: ResourceBatch;
 };
 
-export class Publisher extends Context.Service<
-  Publisher,
-  {
-    readonly publish: (options: {
-      readonly name: string;
-      readonly batch: Batch<Record<string, unknown>>;
-    }) => Effect.Effect<PublishAck, ConnectorError>;
-  }
->()("Publisher") {}
+export interface PublisherService {
+  readonly publish: (options: PublishOptions) => Effect.Effect<PublishAck, ConnectorError>;
+}
+
+export class Publisher extends Context.Service<Publisher, PublisherService>()(
+  "@useairfoil/connector-kit/Publisher",
+) {}

package/src/publisher/wings.ts

@@ -1,117 +1,204 @@
-import type { PartitionValue } from "@useairfoil/wings";
-
 import * as Wings from "@useairfoil/wings";
 import { Effect, Layer } from "effect";
 
-import type { ConnectorDefinition } from "../core/types";
+import type { ConnectorDefinition, ResourceDefinition } from "../core/types";
 
-import { ConnectorError } from "../core/errors";
-import { Publisher } from "./service";
+import { ConnectorError } from "../errors";
+import { SpanName } from "../telemetry";
+import { Publisher, type PublishAck, type PublisherService } from "./service";
 
 type Rows = Record<string, unknown>;
 
+export type WingsTableMapping = {
+  readonly name: string;
+  readonly partitionValue?: Wings.PartitionValue.PartitionValue;
+};
+
 export type WingsPublisherConfig = {
   readonly connector: ConnectorDefinition;
-  /** Map of entity/event name to Wings topic. */
-  readonly topics: Record<string, Wings.Cluster.Topic.Topic>;
-  /** per-stream partition value (key is entity/event name). */
-  readonly partitionValues?: Record<string, PartitionValue>;
+  readonly tables: Record<string, string | WingsTableMapping>;
 };
 
-/** Publisher entry for a single entity/event. */
 type PublisherEntry = {
-  /** Wings publisher for the entity/event. */
+  readonly resource: ResourceDefinition;
+  readonly table: Wings.Cluster.Table.Table;
   readonly publisher: Wings.WingsClient.Publisher;
-  /** Partition field name (if any). */
-  readonly partitionField?: string;
-  /** Partition value (if any). */
-  readonly partitionValue?: PartitionValue;
+  readonly partitionValue?: Wings.PartitionValue.PartitionValue;
+  readonly keyField: Wings.Cluster.ArrowType.Field;
+  readonly versionField: Wings.Cluster.ArrowType.Field;
 };
 
+const normalizeMapping = (mapping: string | WingsTableMapping): WingsTableMapping =>
+  typeof mapping === "string" ? { name: mapping } : mapping;
+
 const buildRecordBatch = (rows: ReadonlyArray<Rows>) => {
-  // Convert JSON rows into an Arrow RecordBatch for Wings.
-  const table = Wings.tableFromJSON(Array.from(rows));
+  const table = Wings.Arrow.tableFromJSON(Array.from(rows));
   const [batch] = table.batches;
-
-  if (!batch) {
-    throw new ConnectorError({ message: "No rows to publish" });
-  }
-
-  return batch;
+  return batch
+    ? Effect.succeed(batch)
+    : Effect.fail(new ConnectorError({ message: "No rows to publish" }));
 };
 
-export const WingsPublisherLayer = (
+const validateTableMapping = (options: {
+  readonly resource: ResourceDefinition;
+  readonly table: Wings.Cluster.Table.Table;
+  readonly partitionValue?: Wings.PartitionValue.PartitionValue;
+}) =>
+  Effect.try({
+    try: () => {
+      const keyField = Wings.TableUtils.getKeyField(options.table);
+      const versionField = Wings.TableUtils.getVersionField(options.table);
+      const partitionField = Wings.TableUtils.getPartitionField(options.table);
+
+      if (keyField.name !== options.resource.key) {
+        throw new Error(
+          `Resource ${options.resource.name} key '${options.resource.key}' does not match Wings table key '${keyField.name}'`,
+        );
+      }
+      if (versionField.name !== options.resource.version) {
+        throw new Error(
+          `Resource ${options.resource.name} version '${options.resource.version}' does not match Wings table version '${versionField.name}'`,
+        );
+      }
+      if (options.resource.partition?.required === true && !options.partitionValue) {
+        throw new Error(`Resource ${options.resource.name} requires a partition value`);
+      }
+      if (partitionField && !options.partitionValue) {
+        throw new Error(
+          `Wings table ${options.table.name} is partitioned but no partition value was provided`,
+        );
+      }
+      if (!partitionField && options.partitionValue) {
+        throw new Error(
+          `Wings table ${options.table.name} is not partitioned but a partition value was provided`,
+        );
+      }
+
+      return { keyField, versionField };
+    },
+    catch: (cause) =>
+      new ConnectorError({
+        message: `Invalid Wings table mapping for ${options.resource.name}`,
+        cause,
+      }),
+  });
+
+const accepted = (entry: PublisherEntry): PublishAck => ({
+  status: "accepted",
+  resource: entry.resource.name,
+  partition: entry.partitionValue,
+});
+
+const rejected = (entry: PublisherEntry, reason: string, rejectedRows: number): PublishAck => ({
+  status: "rejected",
+  resource: entry.resource.name,
+  reason,
+  rejectedRows,
+  partition: entry.partitionValue,
+});
+
+export const layerWings = (
   config: WingsPublisherConfig,
 ): Layer.Layer<Publisher, ConnectorError, Wings.WingsClient.WingsClient> =>
   Layer.effect(Publisher)(
     Effect.gen(function* () {
       const entries = new Map<string, PublisherEntry>();
+      const clusterClient = yield* Wings.WingsClient.clusterClient;
 
-      // create and store a wings publisher for each entity/event.
-      for (const def of [...config.connector.entities, ...config.connector.events]) {
-        const topic = config.topics[def.name];
-        if (!topic) {
+      for (const resource of config.connector.resources) {
+        const mappingInput = config.tables[resource.name];
+        if (!mappingInput) {
           return yield* Effect.fail(
-            new ConnectorError({ message: `Missing topic for ${def.name}` }),
+            new ConnectorError({ message: `Missing table for ${resource.name}` }),
           );
         }
 
-        const partitionIndex =
-          topic.partitionKey !== undefined
-            ? topic.schema.fields.findIndex((field) => field.id === topic.partitionKey)
-            : undefined;
-
-        const partitionField =
-          partitionIndex !== undefined && partitionIndex >= 0
-            ? topic.schema.fields[partitionIndex]?.name
-            : undefined;
+        const mapping = normalizeMapping(mappingInput);
+        const table = yield* clusterClient.getTable({ name: mapping.name }).pipe(
+          Effect.mapError(
+            (error) =>
+              new ConnectorError({
+                message: `Failed to resolve Wings table for ${resource.name}`,
+                cause: error,
+              }),
+          ),
+        );
+        const { keyField, versionField } = yield* validateTableMapping({
+          resource,
+          table,
+          partitionValue: mapping.partitionValue,
+        });
 
         const publisher = yield* Wings.WingsClient.publisher({
-          topic,
-          partitionValue: config.partitionValues?.[def.name],
+          table,
+          partitionValue: mapping.partitionValue,
         }).pipe(
           Effect.mapError((error) => new ConnectorError({ message: error.message, cause: error })),
         );
 
-        entries.set(def.name, {
+        entries.set(resource.name, {
+          resource,
+          table,
           publisher,
-          partitionField,
-          partitionValue: config.partitionValues?.[def.name],
+          partitionValue: mapping.partitionValue,
+          keyField,
+          versionField,
         });
       }
 
-      return {
-        publish: ({ name, batch }) =>
-          Effect.gen(function* () {
-            const entry = entries.get(name);
-            if (!entry) {
-              return yield* Effect.fail(new ConnectorError({ message: `Unknown stream ${name}` }));
-            }
+      const pushRows = (
+        entry: PublisherEntry,
+        operation: "upsert" | "delete",
+        rows: ReadonlyArray<Rows>,
+      ) =>
+        Effect.gen(function* () {
+          if (rows.length === 0) return accepted(entry);
+          const batch = yield* buildRecordBatch(rows);
+          return yield* entry.publisher
+            .push({ operation, batch, partitionValue: entry.partitionValue })
+            .pipe(
+              Effect.matchEffect({
+                onFailure: (error) => Effect.succeed(rejected(entry, error.message, rows.length)),
+                onSuccess: () => Effect.succeed(accepted(entry)),
+              }),
+            );
+        });
 
-            if (batch.rows.length === 0) {
-              return { success: true };
+      const service: PublisherService = {
+        publish: Effect.fn(SpanName.publish, { kind: "producer" })(function* ({
+          resource,
+          source: _source,
+          batch,
+        }) {
+          const entry = entries.get(resource);
+          if (!entry) {
+            return yield* Effect.fail(
+              new ConnectorError({ message: `Unknown resource ${resource}` }),
+            );
+          }
+
+          if (batch.mutations.length === 0) return accepted(entry);
+
+          const upserts: Rows[] = [];
+          const deletes: Rows[] = [];
+          for (const mutation of batch.mutations) {
+            if (mutation.op === "upsert") {
+              upserts.push(mutation.row as Rows);
+            } else {
+              deletes.push({
+                [entry.keyField.name]: mutation.key,
+                [entry.versionField.name]: mutation.version,
+              });
             }
+          }
 
-            const recordBatch = buildRecordBatch(batch.rows);
-            const result = yield* entry.publisher
-              .push({
-                batch: recordBatch,
-                partitionValue: entry.partitionValue,
-              })
-              .pipe(
-                Effect.mapError(
-                  (error) =>
-                    new ConnectorError({
-                      message: error.message,
-                      cause: error,
-                    }),
-                ),
-              );
-
-            return {
-              success: !!(result.result && result.result.$case === "accepted"),
-            };
-          }),
+          const upsertAck = yield* pushRows(entry, "upsert", upserts);
+          if (upsertAck.status === "rejected") return upsertAck;
+
+          return yield* pushRows(entry, "delete", deletes);
+        }),
       };
+
+      return Publisher.of(service);
     }),
   );

package/src/runtime/context.ts

@@ -0,0 +1,15 @@
+import { Context, Layer } from "effect";
+
+import type { ConnectorDefinition } from "../core/types";
+
+export type ConnectorRuntimeContextValue = {
+  readonly connector: ConnectorDefinition;
+};
+
+export class ConnectorRuntimeContext extends Context.Service<
+  ConnectorRuntimeContext,
+  ConnectorRuntimeContextValue
+>()("@useairfoil/connector-kit/ConnectorRuntimeContext") {}
+
+export const layer = (connector: ConnectorDefinition) =>
+  Layer.succeed(ConnectorRuntimeContext)(ConnectorRuntimeContext.of({ connector }));

package/src/runtime-config/constants.ts

@@ -0,0 +1,27 @@
+import { HashSet } from "effect";
+
+/** Shared runtime keys owned by Airfoil rather than an individual connector. */
+export const PlatformRuntimeKey = {
+  configPath: "AIRFOIL_CONFIG_PATH",
+  connectorInstanceId: "AIRFOIL_CONNECTOR_INSTANCE_ID",
+  stateTable: "AIRFOIL_STATE_TABLE",
+  postgresConnectionString: "POSTGRES_CONNECTION_STRING",
+  wingsHost: "WINGS_HOST",
+  wingsNamespace: "WINGS_NAMESPACE",
+  otelEnabled: "OTEL_ENABLED",
+  otelExporterOtlpEndpoint: "OTEL_EXPORTER_OTLP_ENDPOINT",
+  otelExporterOtlpHeaders: "OTEL_EXPORTER_OTLP_HEADERS",
+  otelServiceName: "OTEL_SERVICE_NAME",
+  otelServiceVersion: "OTEL_SERVICE_VERSION",
+  otelResourceAttributes: "OTEL_RESOURCE_ATTRIBUTES",
+} as const;
+
+/** Defaults for optional platform-owned runtime configuration. */
+export const PlatformRuntimeDefault = {
+  stateTable: "_airfoil_connectors_state",
+} as const;
+
+const platformRuntimeKeys = HashSet.fromIterable(Object.values(PlatformRuntimeKey));
+
+/** @internal */
+export const isPlatformRuntimeKey = (key: string): boolean => HashSet.has(platformRuntimeKeys, key);

package/src/runtime-config/error.ts

@@ -0,0 +1,13 @@
+import { Data } from "effect";
+
+export type RuntimeConfigErrorCode =
+  | "CONFIG_PATH_MISSING"
+  | "CONFIG_FILE_UNREADABLE"
+  | "CONFIG_JSON_INVALID";
+
+/** Expected hosted-config failure with a stable code and diagnostic cause. */
+export class RuntimeConfigError extends Data.TaggedError("RuntimeConfigError")<{
+  readonly code: RuntimeConfigErrorCode;
+  readonly message: string;
+  readonly cause: Error;
+}> {}

package/src/runtime-config/index.ts

@@ -0,0 +1,3 @@
+export { RuntimeConfigError, type RuntimeConfigErrorCode } from "./error";
+export { PlatformRuntimeDefault, PlatformRuntimeKey } from "./constants";
+export { layerHosted } from "./layer";

package/src/runtime-config/layer.ts

@@ -0,0 +1,56 @@
+import { Config, ConfigProvider, Effect, FileSystem, Schema } from "effect";
+
+import { PlatformRuntimeKey } from "./constants";
+import { RuntimeConfigError } from "./error";
+
+const providerFromFile: Effect.Effect<
+  ConfigProvider.ConfigProvider,
+  RuntimeConfigError,
+  FileSystem.FileSystem
+> = Effect.gen(function* () {
+  const configPath = yield* Config.nonEmptyString(PlatformRuntimeKey.configPath).pipe(
+    Effect.mapError(
+      (error) =>
+        new RuntimeConfigError({
+          code: "CONFIG_PATH_MISSING",
+          message: `${PlatformRuntimeKey.configPath} is required in hosted mode`,
+          cause: error.cause,
+        }),
+    ),
+  );
+  const fileSystem = yield* FileSystem.FileSystem;
+  const contents = yield* fileSystem.readFileString(configPath).pipe(
+    Effect.mapError(
+      (cause) =>
+        new RuntimeConfigError({
+          code: "CONFIG_FILE_UNREADABLE",
+          message: "Connector config file could not be read",
+          cause,
+        }),
+    ),
+  );
+  const document = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(
+    contents,
+  ).pipe(
+    Effect.mapError(
+      (error) =>
+        new RuntimeConfigError({
+          code: "CONFIG_JSON_INVALID",
+          message: "Connector config is not valid JSON",
+          cause: error,
+        }),
+    ),
+  );
+  return ConfigProvider.fromUnknown(document, { preserveEmptyStrings: true });
+});
+
+/**
+ * Loads the required JSON file and lets environment values override it per key.
+ * Connector field validation remains in the connector's Effect Config.
+ *
+ * @example
+ * ```ts
+ * program.pipe(Effect.provide(layerHosted()));
+ * ```
+ */
+export const layerHosted = () => ConfigProvider.layerAdd(providerFromFile);

package/src/state-store/index.ts

@@ -0,0 +1,3 @@
+export { StateStore, type StateStoreService } from "./service";
+export { layerMemory } from "./layer-memory";
+export { layerSql } from "./layer-sql";

package/src/state-store/keys.ts

@@ -0,0 +1,22 @@
+import type { StateSource } from "./schema";
+
+type StateComponent = StateSource | `error:${StateSource}`;
+
+export const resourceComponentKey = (resource: string, component: StateComponent): string =>
+  `resource:${resource}:${component}`;
+
+export const resourceErrorKey = (resource: string, source: StateSource): string =>
+  resourceComponentKey(resource, `error:${source}`);
+
+/**
+ * Prefix for all state owned by one connector instance. The platform-owned ID
+ * stays visible so operators can inspect and clean up shared-table rows directly.
+ *
+ * @example
+ * ```ts
+ * connectorInstanceKeyPrefix("team-a/orders");
+ * // "connector-instance:team-a/orders:"
+ * ```
+ */
+export const connectorInstanceKeyPrefix = (connectorInstanceId: string): string =>
+  `connector-instance:${connectorInstanceId}:`;

package/src/state-store/layer-key-value-store.ts

@@ -0,0 +1,132 @@
+import { DateTime, Effect, Layer, Option, Schema } from "effect";
+import { KeyValueStore } from "effect/unstable/persistence";
+
+import { ConnectorError } from "../errors";
+import { resourceComponentKey, resourceErrorKey } from "./keys";
+import {
+  BackfillStateSchema,
+  ChangesStateSchema,
+  ResourceErrorSchema,
+  type PersistedBackfillState,
+  type PersistedChangesState,
+  type PersistedResourceError,
+  type ResourceErrorContext,
+  type StateOperation,
+  type StateSource,
+} from "./schema";
+import { StateStore } from "./service";
+
+const mapStoreError = (operation: "read" | "write" | "clear", resource: string) =>
+  Effect.mapError(
+    (cause: KeyValueStore.KeyValueStoreError | Schema.SchemaError) =>
+      new ConnectorError({
+        message: `Failed to ${operation} state for resource ${resource}`,
+        cause,
+      }),
+  );
+
+const resourceErrorContext = (
+  source: StateSource,
+  operation: StateOperation,
+): ResourceErrorContext => {
+  const sourceName = source === "backfill" ? "Backfill" : "Changes";
+  switch (operation) {
+    case "fetch":
+      return { source, operation, code: "fetch_failed", message: `${sourceName} fetch failed` };
+    case "publish":
+      return { source, operation, code: "publish_failed", message: `${sourceName} publish failed` };
+    case "checkpoint":
+      return {
+        source,
+        operation,
+        code: "checkpoint_failed",
+        message: `${sourceName} checkpoint failed`,
+      };
+  }
+};
+
+const latestError = (
+  backfill: Option.Option<PersistedResourceError>,
+  changes: Option.Option<PersistedResourceError>,
+): Option.Option<PersistedResourceError> => {
+  if (Option.isNone(backfill)) return changes;
+  if (Option.isNone(changes)) return backfill;
+  return backfill.value.at >= changes.value.at ? backfill : changes;
+};
+
+/**
+ * Implements StateStore over any Effect KeyValueStore. `toSchemaStore` owns
+ * serialization and validates persisted values when they are read and written.
+ * The caller owns instance scoping; `layerSql` supplies the production prefix.
+ */
+export const layerKeyValueStore: Layer.Layer<StateStore, never, KeyValueStore.KeyValueStore> =
+  Layer.effect(StateStore)(
+    Effect.gen(function* () {
+      const keyValueStore = yield* KeyValueStore.KeyValueStore;
+      const backfillStore = KeyValueStore.toSchemaStore(keyValueStore, BackfillStateSchema);
+      const changesStore = KeyValueStore.toSchemaStore(keyValueStore, ChangesStateSchema);
+      const errorStore = KeyValueStore.toSchemaStore(keyValueStore, ResourceErrorSchema);
+
+      const getResourceState = (resource: string) =>
+        // Components use separate keys so a cursor update cannot overwrite the
+        // independently managed error or backfill state.
+        Effect.all(
+          {
+            backfill: backfillStore.get(resourceComponentKey(resource, "backfill")),
+            changes: changesStore.get(resourceComponentKey(resource, "changes")),
+            backfillError: errorStore.get(resourceErrorKey(resource, "backfill")),
+            changesError: errorStore.get(resourceErrorKey(resource, "changes")),
+          },
+          { concurrency: "unbounded" },
+        ).pipe(
+          Effect.map(({ backfill, changes, backfillError, changesError }) => {
+            const lastError = latestError(backfillError, changesError);
+            if (Option.isNone(backfill) && Option.isNone(changes) && Option.isNone(lastError)) {
+              return undefined;
+            }
+            return {
+              ...(Option.isSome(backfill) ? { backfill: backfill.value } : {}),
+              ...(Option.isSome(changes) ? { changes: changes.value } : {}),
+              ...(Option.isSome(lastError) ? { lastError: lastError.value } : {}),
+            };
+          }),
+          mapStoreError("read", resource),
+        );
+
+      const setBackfillState = (resource: string, state: PersistedBackfillState) =>
+        backfillStore
+          .set(resourceComponentKey(resource, "backfill"), state)
+          .pipe(mapStoreError("write", resource));
+
+      const setChangesState = (resource: string, state: PersistedChangesState) =>
+        changesStore
+          .set(resourceComponentKey(resource, "changes"), state)
+          .pipe(mapStoreError("write", resource));
+
+      const setResourceError = (resource: string, source: StateSource, operation: StateOperation) =>
+        DateTime.now.pipe(
+          Effect.map(DateTime.formatIso),
+          Effect.flatMap((at) => {
+            const error = resourceErrorContext(source, operation);
+            return errorStore.set(resourceErrorKey(resource, source), {
+              ...error,
+              at,
+            });
+          }),
+          mapStoreError("write", resource),
+        );
+
+      const clearResourceError = (resource: string, source: StateSource) =>
+        errorStore
+          .remove(resourceErrorKey(resource, source))
+          .pipe(mapStoreError("clear", resource));
+
+      return StateStore.of({
+        getResourceState,
+        setBackfillState,
+        setChangesState,
+        setResourceError,
+        clearResourceError,
+      });
+    }),
+  );

package/src/state-store/layer-memory.ts

@@ -0,0 +1,11 @@
+import { Layer } from "effect";
+import { KeyValueStore } from "effect/unstable/persistence";
+
+import type { StateStore } from "./service";
+
+import { layerKeyValueStore } from "./layer-key-value-store";
+
+/** Process-local state for tests and explicit local sandbox commands. */
+export const layerMemory: Layer.Layer<StateStore> = layerKeyValueStore.pipe(
+  Layer.provide(KeyValueStore.layerMemory),
+);

package/src/state-store/layer-sql.ts

@@ -0,0 +1,50 @@
+import { Config, Effect, Layer } from "effect";
+import { KeyValueStore } from "effect/unstable/persistence";
+import { SqlClient } from "effect/unstable/sql";
+
+import type { StateStore } from "./service";
+
+import { PlatformRuntimeDefault, PlatformRuntimeKey } from "../runtime-config/constants";
+import { connectorInstanceKeyPrefix } from "./keys";
+import { layerKeyValueStore } from "./layer-key-value-store";
+
+const scopedKeyValueStore = (connectorInstanceId: string) =>
+  Layer.effect(KeyValueStore.KeyValueStore)(
+    KeyValueStore.KeyValueStore.pipe(
+      Effect.map(KeyValueStore.prefix(connectorInstanceKeyPrefix(connectorInstanceId))),
+    ),
+  );
+
+/**
+ * Shared SQL state using the immutable connector instance ID supplied by
+ * platform-owned Effect configuration. The table defaults to
+ * `_airfoil_connectors_state` and can be overridden with `AIRFOIL_STATE_TABLE`.
+ * Effect's SQL KeyValueStore owns the table, while `KeyValueStore.prefix`
+ * provides application-level isolation between connector instances in that
+ * table. The resulting layer exposes only StateStore, never the unscoped
+ * KeyValueStore.
+ *
+ * @example
+ * ```ts
+ * const StateStoreLive = layerSql().pipe(Layer.provide(PostgresLive));
+ * ```
+ */
+export const layerSql = (): Layer.Layer<StateStore, Config.ConfigError, SqlClient.SqlClient> =>
+  Layer.unwrap(
+    Config.all({
+      connectorInstanceId: Config.nonEmptyString(PlatformRuntimeKey.connectorInstanceId),
+      table: Config.nonEmptyString(PlatformRuntimeKey.stateTable).pipe(
+        Config.withDefault(PlatformRuntimeDefault.stateTable),
+      ),
+    }).pipe(
+      Effect.map(({ connectorInstanceId, table }) =>
+        layerKeyValueStore.pipe(
+          Layer.provide(
+            scopedKeyValueStore(connectorInstanceId).pipe(
+              Layer.provide(KeyValueStore.layerSql({ table })),
+            ),
+          ),
+        ),
+      ),
+    ),
+  );