effect-cf 0.14.0 → 0.16.0

package/src/AnalyticsEngine.ts

@@ -0,0 +1,846 @@
+import type {
+  AnalyticsEngineDataPoint as CloudflareAnalyticsEngineDataPoint,
+  AnalyticsEngineDataset as CloudflareAnalyticsEngineDataset,
+} from "@cloudflare/workers-types";
+import {
+  Config,
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Option,
+  Redacted,
+  Result,
+  Schema as S,
+} from "effect";
+import {
+  FetchHttpClient,
+  type Headers,
+  HttpClient,
+  type HttpClientResponse,
+  HttpClientRequest,
+} from "effect/unstable/http";
+
+import * as Binding from "./Binding";
+import type { WorkerEnvironment } from "./Environment";
+
+const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
+const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
+const textEncoder = new TextEncoder();
+
+export const writeLimits = {
+  maxBlobs: 20,
+  maxDoubles: 20,
+  maxIndexes: 1,
+  maxBlobBytes: 16 * 1024,
+  maxIndexBytes: 96,
+  maxDataPointsPerInvocation: 250,
+} as const;
+
+const queryColumnSchema = S.Struct({
+  name: S.String,
+  type: S.String,
+});
+
+const queryRowSchema = S.Record(S.String, S.Unknown);
+
+const queryResponseSchema = S.Struct({
+  meta: S.Array(queryColumnSchema),
+  data: S.Array(queryRowSchema),
+  rows: S.Number,
+});
+
+export const AnalyticsEngineFieldValueSchema = S.NullOr(
+  S.Union([S.String, S.instanceOf(ArrayBuffer)]),
+);
+
+export const AnalyticsEngineDataPointSchema = S.Struct({
+  indexes: S.optional(S.Array(AnalyticsEngineFieldValueSchema)),
+  doubles: S.optional(S.Array(S.Finite)),
+  blobs: S.optional(S.Array(AnalyticsEngineFieldValueSchema)),
+});
+
+const decodeQueryResponse = S.decodeUnknownEffect(queryResponseSchema);
+const decodeDataPoint = S.decodeUnknownEffect(AnalyticsEngineDataPointSchema);
+
+/** Error raised when an Analytics Engine operation fails. */
+export class AnalyticsEngineOperationError extends Data.TaggedError(
+  "AnalyticsEngineOperationError",
+)<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+
+export interface AnalyticsEngineWriteViolation {
+  readonly path: string;
+  readonly message: string;
+  readonly limit?: number;
+  readonly actual?: number;
+}
+
+/** Error raised when an Analytics Engine write input violates Cloudflare limits. */
+export class AnalyticsEngineWriteValidationError extends Data.TaggedError(
+  "AnalyticsEngineWriteValidationError",
+)<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
+  readonly cause?: unknown;
+}> {}
+
+/** Error raised when an Analytics Engine SQL API query fails. */
+export class AnalyticsEngineQueryError extends Data.TaggedError("AnalyticsEngineQueryError")<{
+  readonly operation: string;
+  readonly accountId: string;
+  readonly message: string;
+  readonly status?: number;
+  readonly body?: string;
+  readonly cause?: unknown;
+}> {}
+
+/** Typed Analytics Engine dataset binding definition. */
+export interface AnalyticsEngineDefinition {
+  /** Binding name as configured in `wrangler.jsonc`. */
+  readonly binding: string;
+}
+
+export type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
+export type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
+export type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
+export type AnalyticsEngineWriteError =
+  | AnalyticsEngineOperationError
+  | AnalyticsEngineWriteValidationError;
+export type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
+export type AnalyticsEngineQueryColumn = S.Schema.Type<typeof queryColumnSchema>;
+export type AnalyticsEngineQueryRow = S.Schema.Type<typeof queryRowSchema>;
+
+export interface AnalyticsEngineWriteOptions {
+  /**
+   * Controls invalid write behavior. The default is `"error"`, which fails with
+   * `AnalyticsEngineWriteValidationError`. `"drop"` skips invalid points.
+   */
+  readonly onInvalid?: AnalyticsEngineInvalidWritePolicy;
+}
+
+export interface AnalyticsEngineWriteBatchOptions extends AnalyticsEngineWriteOptions {
+  /**
+   * Maximum points per native batch call. Values are clamped to Cloudflare's
+   * per-invocation limit.
+   */
+  readonly batchSize?: number;
+}
+
+export type AnalyticsEngineWritePolicy = AnalyticsEngineWriteBatchOptions;
+
+export interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
+  readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
+  readonly data: ReadonlyArray<Row>;
+  readonly rows: number;
+}
+
+export interface AnalyticsEngineQueryDefinition {
+  /** Cloudflare account id that owns the Analytics Engine datasets. */
+  readonly accountId: string;
+  /** API token with Account Analytics Read permission. */
+  readonly apiToken: Redacted.Redacted<string>;
+  /** Base Cloudflare API URL. Defaults to `https://api.cloudflare.com/client/v4`. */
+  readonly apiBaseUrl?: string | URL;
+}
+
+export interface AnalyticsEngineQueryOptions {
+  /** Additional request headers. Authorization is always derived from `apiToken`. */
+  readonly headers?: Headers.Input;
+}
+
+export interface AnalyticsEngineClient {
+  readonly writeDataPoint: (
+    dataPoint?: AnalyticsEngineDataPoint,
+    options?: AnalyticsEngineWriteOptions,
+  ) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly write: (
+    dataPoint?: AnalyticsEngineDataPoint,
+    options?: AnalyticsEngineWriteOptions,
+  ) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoints: (
+    dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
+    options?: AnalyticsEngineWriteBatchOptions,
+  ) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeBatch: (
+    dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
+    options?: AnalyticsEngineWriteBatchOptions,
+  ) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly unsafeRaw: Effect.Effect<AnalyticsEngineBinding>;
+  readonly definition: AnalyticsEngineDefinition;
+}
+
+export interface AnalyticsEngineQueryClient {
+  readonly query: (
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<AnalyticsEngineQueryResult, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryResult: <Row>(
+    row: S.Codec<Row, unknown>,
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<AnalyticsEngineQueryResult<Row>, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryRows: <Row>(
+    row: S.Codec<Row, unknown>,
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<ReadonlyArray<Row>, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryOne: <Row>(
+    row: S.Codec<Row, unknown>,
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<Option.Option<Row>, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryText: (
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<string, AnalyticsEngineQueryError>;
+  readonly raw: (
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) => Effect.Effect<HttpClientResponse.HttpClientResponse, AnalyticsEngineQueryError>;
+  readonly definition: AnalyticsEngineQueryDefinition;
+}
+
+declare const AnalyticsEngineServiceTypeId: unique symbol;
+declare const AnalyticsEngineQueryServiceTypeId: unique symbol;
+
+/** Nominal service marker for Analytics Engine services created with {@link make}. */
+export interface AnalyticsEngineService<Id extends string> {
+  readonly [AnalyticsEngineServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+/** Nominal service marker for Analytics Engine query services created with {@link makeQuery}. */
+export interface AnalyticsEngineQueryService<Id extends string> {
+  readonly [AnalyticsEngineQueryServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+
+export type LayerOptions = {
+  readonly binding: string;
+  readonly write?: AnalyticsEngineWritePolicy;
+};
+
+export type QueryConfigOptions = {
+  readonly accountId?: Config.Config<string>;
+  readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
+  readonly apiBaseUrl?: Config.Config<string>;
+};
+
+export interface TagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  AnalyticsEngineClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    options: LayerOptions,
+  ) => Layer.Layer<
+    Self,
+    Binding.BindingNotFoundError | Binding.BindingValidationError,
+    WorkerEnvironment
+  >;
+}
+
+export interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<
+  Self,
+  Id,
+  AnalyticsEngineQueryClient
+> {
+  readonly id: Id;
+  readonly layer: (
+    definition: AnalyticsEngineQueryDefinition,
+  ) => Layer.Layer<Self, never, HttpClient.HttpClient>;
+  readonly fetchLayer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
+  readonly layerConfig: (
+    config?: Config.Config<AnalyticsEngineQueryDefinition>,
+  ) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
+  readonly fetchLayerConfig: (
+    config?: Config.Config<AnalyticsEngineQueryDefinition>,
+  ) => Layer.Layer<Self, Config.ConfigError>;
+}
+
+const analyticsEngineError = (binding: string, operation: string, cause: unknown) =>
+  new AnalyticsEngineOperationError({ binding, operation, cause });
+
+const analyticsEngineWriteValidationError = (
+  binding: string,
+  operation: string,
+  violations: ReadonlyArray<AnalyticsEngineWriteViolation>,
+  cause?: unknown,
+) =>
+  new AnalyticsEngineWriteValidationError({
+    binding,
+    operation,
+    violations,
+    cause,
+  });
+
+const analyticsEngineQueryError = (
+  definition: AnalyticsEngineQueryDefinition,
+  operation: string,
+  message: string,
+  options?: {
+    readonly status?: number;
+    readonly body?: string;
+    readonly cause?: unknown;
+  },
+) =>
+  new AnalyticsEngineQueryError({
+    operation,
+    accountId: definition.accountId,
+    message,
+    status: options?.status,
+    body: options?.body,
+    cause: options?.cause,
+  });
+
+const tryAnalyticsEngineSync = <A>(
+  binding: string,
+  operation: string,
+  evaluate: () => A,
+): Effect.Effect<A, AnalyticsEngineOperationError> =>
+  Effect.try({
+    try: evaluate,
+    catch: (cause) => analyticsEngineError(binding, operation, cause),
+  });
+
+const normalizeBatchSize = (batchSize: number | undefined) => {
+  if (batchSize === undefined || !Number.isFinite(batchSize) || batchSize <= 0) {
+    return writeLimits.maxDataPointsPerInvocation;
+  }
+
+  return Math.min(Math.floor(batchSize), writeLimits.maxDataPointsPerInvocation);
+};
+
+const resolveWritePolicy = (
+  defaults: AnalyticsEngineWritePolicy | undefined,
+  options: AnalyticsEngineWriteBatchOptions | undefined,
+) => ({
+  onInvalid: options?.onInvalid ?? defaults?.onInvalid ?? "error",
+  batchSize: normalizeBatchSize(options?.batchSize ?? defaults?.batchSize),
+});
+
+const fieldPath = (prefix: string, field: string) => (prefix === "" ? field : `${prefix}.${field}`);
+
+const indexedPath = (prefix: string, field: string, index: number) =>
+  `${fieldPath(prefix, field)}[${index}]`;
+
+const byteLength = (value: AnalyticsEngineFieldValue) => {
+  if (value === null) {
+    return 0;
+  }
+
+  return typeof value === "string" ? textEncoder.encode(value).byteLength : value.byteLength;
+};
+
+const lengthViolation = (
+  path: string,
+  label: string,
+  actual: number,
+  limit: number,
+): AnalyticsEngineWriteViolation => ({
+  path,
+  message: `${label} exceeds Cloudflare Analytics Engine limit`,
+  actual,
+  limit,
+});
+
+const validateDataPointLimits = (
+  dataPoint: AnalyticsEngineDataPoint,
+  pathPrefix = "",
+): ReadonlyArray<AnalyticsEngineWriteViolation> => {
+  const violations: Array<AnalyticsEngineWriteViolation> = [];
+
+  if (dataPoint.blobs !== undefined && dataPoint.blobs.length > writeLimits.maxBlobs) {
+    violations.push(
+      lengthViolation(
+        fieldPath(pathPrefix, "blobs"),
+        "blobs",
+        dataPoint.blobs.length,
+        writeLimits.maxBlobs,
+      ),
+    );
+  }
+
+  if (dataPoint.doubles !== undefined && dataPoint.doubles.length > writeLimits.maxDoubles) {
+    violations.push(
+      lengthViolation(
+        fieldPath(pathPrefix, "doubles"),
+        "doubles",
+        dataPoint.doubles.length,
+        writeLimits.maxDoubles,
+      ),
+    );
+  }
+
+  if (dataPoint.indexes !== undefined && dataPoint.indexes.length > writeLimits.maxIndexes) {
+    violations.push(
+      lengthViolation(
+        fieldPath(pathPrefix, "indexes"),
+        "indexes",
+        dataPoint.indexes.length,
+        writeLimits.maxIndexes,
+      ),
+    );
+  }
+
+  if (dataPoint.blobs !== undefined) {
+    const blobBytes = dataPoint.blobs.reduce((total, value) => total + byteLength(value), 0);
+
+    if (blobBytes > writeLimits.maxBlobBytes) {
+      violations.push(
+        lengthViolation(
+          fieldPath(pathPrefix, "blobs"),
+          "blob bytes",
+          blobBytes,
+          writeLimits.maxBlobBytes,
+        ),
+      );
+    }
+  }
+
+  if (dataPoint.indexes !== undefined) {
+    for (let index = 0; index < dataPoint.indexes.length; index++) {
+      const indexBytes = byteLength(dataPoint.indexes[index] ?? null);
+
+      if (indexBytes > writeLimits.maxIndexBytes) {
+        violations.push(
+          lengthViolation(
+            indexedPath(pathPrefix, "indexes", index),
+            "index bytes",
+            indexBytes,
+            writeLimits.maxIndexBytes,
+          ),
+        );
+      }
+    }
+  }
+
+  return violations;
+};
+
+const schemaViolation = (
+  pathPrefix: string,
+  cause: S.SchemaError,
+): AnalyticsEngineWriteViolation => ({
+  path: pathPrefix === "" ? "$" : pathPrefix,
+  message: cause.message,
+});
+
+const toAnalyticsEngineDataPoint = (
+  dataPoint: S.Schema.Type<typeof AnalyticsEngineDataPointSchema>,
+): AnalyticsEngineDataPoint => ({
+  ...(dataPoint.indexes === undefined ? {} : { indexes: [...dataPoint.indexes] }),
+  ...(dataPoint.doubles === undefined ? {} : { doubles: [...dataPoint.doubles] }),
+  ...(dataPoint.blobs === undefined ? {} : { blobs: [...dataPoint.blobs] }),
+});
+
+const validateDataPoint = (
+  binding: string,
+  operation: string,
+  dataPoint: AnalyticsEngineDataPoint,
+  pathPrefix = "",
+): Effect.Effect<AnalyticsEngineDataPoint, AnalyticsEngineWriteValidationError> =>
+  Effect.gen(function* () {
+    const decoded = yield* decodeDataPoint(dataPoint).pipe(
+      Effect.mapError((cause) =>
+        analyticsEngineWriteValidationError(
+          binding,
+          operation,
+          [schemaViolation(pathPrefix, cause)],
+          cause,
+        ),
+      ),
+    );
+    const validated = toAnalyticsEngineDataPoint(decoded);
+    const violations = validateDataPointLimits(validated, pathPrefix);
+
+    if (violations.length > 0) {
+      return yield* Effect.fail(
+        analyticsEngineWriteValidationError(binding, operation, violations),
+      );
+    }
+
+    return validated;
+  });
+
+const validateOptionalDataPoint = (
+  binding: string,
+  operation: string,
+  dataPoint: AnalyticsEngineDataPoint | undefined,
+): Effect.Effect<AnalyticsEngineDataPoint | undefined, AnalyticsEngineWriteValidationError> =>
+  dataPoint === undefined
+    ? Effect.succeed(undefined)
+    : validateDataPoint(binding, operation, dataPoint);
+
+const validateDataPoints = (
+  binding: string,
+  operation: string,
+  dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
+  policy: ReturnType<typeof resolveWritePolicy>,
+): Effect.Effect<ReadonlyArray<AnalyticsEngineDataPoint>, AnalyticsEngineWriteValidationError> =>
+  Effect.gen(function* () {
+    const points =
+      dataPoints.length > writeLimits.maxDataPointsPerInvocation && policy.onInvalid === "drop"
+        ? dataPoints.slice(0, writeLimits.maxDataPointsPerInvocation)
+        : dataPoints;
+    const violations: Array<AnalyticsEngineWriteViolation> = [];
+
+    if (
+      dataPoints.length > writeLimits.maxDataPointsPerInvocation &&
+      policy.onInvalid === "error"
+    ) {
+      violations.push(
+        lengthViolation(
+          "dataPoints",
+          "data points per Worker invocation",
+          dataPoints.length,
+          writeLimits.maxDataPointsPerInvocation,
+        ),
+      );
+    }
+
+    const validPoints: Array<AnalyticsEngineDataPoint> = [];
+
+    for (let index = 0; index < points.length; index++) {
+      const result = yield* Effect.result(
+        validateDataPoint(binding, operation, points[index], `dataPoints[${index}]`),
+      );
+
+      if (Result.isSuccess(result)) {
+        validPoints.push(result.success);
+      } else if (policy.onInvalid === "error") {
+        violations.push(...result.failure.violations);
+      }
+    }
+
+    if (violations.length > 0) {
+      return yield* Effect.fail(
+        analyticsEngineWriteValidationError(binding, operation, violations),
+      );
+    }
+
+    return validPoints;
+  });
+
+const writeChunks = (
+  binding: string,
+  operation: string,
+  dataset: AnalyticsEngineBinding,
+  dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
+  batchSize: number,
+): Effect.Effect<void, AnalyticsEngineOperationError> =>
+  Effect.gen(function* () {
+    const writeDataPoints = Reflect.get(dataset, "writeDataPoints");
+
+    for (let index = 0; index < dataPoints.length; index += batchSize) {
+      const chunk = dataPoints.slice(index, index + batchSize);
+
+      if (typeof writeDataPoints === "function") {
+        yield* tryAnalyticsEngineSync(binding, operation, () =>
+          writeDataPoints.call(dataset, chunk),
+        );
+      } else {
+        for (const point of chunk) {
+          yield* tryAnalyticsEngineSync(binding, operation, () => dataset.writeDataPoint(point));
+        }
+      }
+    }
+  });
+
+const queryApiUrl = (definition: AnalyticsEngineQueryDefinition) => {
+  const baseUrl = new URL(definition.apiBaseUrl ?? defaultQueryApiBaseUrl);
+  const pathname = baseUrl.pathname.replace(/\/+$/, "");
+  baseUrl.pathname = `${pathname}/accounts/${definition.accountId}/analytics_engine/sql`;
+  return baseUrl.href;
+};
+
+const queryRequest = (
+  definition: AnalyticsEngineQueryDefinition,
+  sql: string,
+  options?: AnalyticsEngineQueryOptions,
+) => {
+  let request = HttpClientRequest.post(queryApiUrl(definition)).pipe(
+    HttpClientRequest.bodyText(sql, "text/plain;charset=UTF-8"),
+  );
+
+  if (options?.headers !== undefined) {
+    request = HttpClientRequest.setHeaders(request, options.headers);
+  }
+
+  return HttpClientRequest.bearerToken(request, definition.apiToken);
+};
+
+const responseText = (
+  definition: AnalyticsEngineQueryDefinition,
+  response: HttpClientResponse.HttpClientResponse,
+  operation: string,
+) =>
+  response.text.pipe(
+    Effect.catch((cause) =>
+      Effect.fail(
+        analyticsEngineQueryError(
+          definition,
+          operation,
+          "Failed to read Analytics Engine SQL API response body",
+          { cause },
+        ),
+      ),
+    ),
+  );
+
+const executeQueryRequest = (
+  definition: AnalyticsEngineQueryDefinition,
+  httpClient: HttpClient.HttpClient,
+  sql: string,
+  options?: AnalyticsEngineQueryOptions,
+) =>
+  Effect.gen(function* () {
+    const response = yield* httpClient.execute(queryRequest(definition, sql, options)).pipe(
+      Effect.mapError((cause) =>
+        analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", {
+          cause,
+        }),
+      ),
+    );
+
+    if (response.status < 200 || response.status >= 300) {
+      const body = yield* responseText(definition, response, "queryErrorBody");
+      return yield* Effect.fail(
+        analyticsEngineQueryError(
+          definition,
+          "query",
+          `Analytics Engine SQL API returned HTTP ${response.status}`,
+          { status: response.status, body },
+        ),
+      );
+    }
+
+    return response;
+  });
+
+const makeQueryClientWith = (
+  definition: AnalyticsEngineQueryDefinition,
+  httpClient: HttpClient.HttpClient,
+): AnalyticsEngineQueryClient => {
+  const raw = (sql: string, options?: AnalyticsEngineQueryOptions) =>
+    executeQueryRequest(definition, httpClient, sql, options);
+  const query = (sql: string, options?: AnalyticsEngineQueryOptions) =>
+    Effect.gen(function* () {
+      const response = yield* raw(sql, options);
+      const json = yield* response.json.pipe(
+        Effect.catch((cause) =>
+          Effect.fail(
+            analyticsEngineQueryError(
+              definition,
+              "json",
+              "Failed to read Analytics Engine SQL API JSON response body",
+              { cause },
+            ),
+          ),
+        ),
+      );
+      return yield* decodeQueryResponse(json);
+    });
+  const queryResult = <Row>(
+    row: S.Codec<Row, unknown>,
+    sql: string,
+    options?: AnalyticsEngineQueryOptions,
+  ) =>
+    Effect.gen(function* () {
+      const result = yield* query(sql, options);
+      const decodeRow = S.decodeUnknownEffect(row);
+      const data: Array<Row> = [];
+
+      for (const value of result.data) {
+        data.push(yield* decodeRow(value));
+      }
+
+      return {
+        ...result,
+        data,
+        rows: result.rows,
+      } satisfies AnalyticsEngineQueryResult<Row>;
+    });
+
+  return {
+    definition,
+    raw,
+    query,
+    queryResult,
+    queryRows: (row, sql, options) =>
+      queryResult(row, sql, options).pipe(Effect.map((result) => result.data)),
+    queryOne: (row, sql, options) =>
+      queryResult(row, sql, options).pipe(
+        Effect.map((result) =>
+          result.data[0] === undefined ? Option.none() : Option.some(result.data[0]),
+        ),
+      ),
+    queryText: (sql, options) =>
+      raw(sql, options).pipe(
+        Effect.flatMap((response) => responseText(definition, response, "text")),
+      ),
+  };
+};
+
+export const makeQueryClient = (definition: AnalyticsEngineQueryDefinition) =>
+  Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
+
+export const isAnalyticsEngineDataset = (value: unknown): value is AnalyticsEngineBinding => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  return typeof Reflect.get(value, "writeDataPoint") === "function";
+};
+
+export const makeClient =
+  (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) =>
+  (dataset: AnalyticsEngineBinding): AnalyticsEngineClient => {
+    const writeDataPoint = (
+      dataPoint?: AnalyticsEngineDataPoint,
+      options?: AnalyticsEngineWriteOptions,
+    ) => {
+      const policy = resolveWritePolicy(defaults, options);
+
+      return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(
+        Effect.matchEffect({
+          onFailure: (error) =>
+            policy.onInvalid === "drop" ? Effect.succeed(undefined) : Effect.fail(error),
+          onSuccess: (point) =>
+            tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () =>
+              dataset.writeDataPoint(point),
+            ),
+        }),
+      );
+    };
+
+    const writeDataPoints = (
+      dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>,
+      options?: AnalyticsEngineWriteBatchOptions,
+    ) => {
+      const policy = resolveWritePolicy(defaults, options);
+
+      return Effect.gen(function* () {
+        const validPoints = yield* validateDataPoints(
+          definition.binding,
+          "writeDataPoints",
+          dataPoints,
+          policy,
+        );
+
+        yield* writeChunks(
+          definition.binding,
+          "writeDataPoints",
+          dataset,
+          validPoints,
+          policy.batchSize,
+        );
+      });
+    };
+
+    return {
+      definition,
+      writeDataPoint,
+      write: writeDataPoint,
+      writeDataPoints,
+      writeBatch: writeDataPoints,
+      unsafeRaw: Effect.succeed(dataset),
+    };
+  };
+
+export const queryConfig = (options?: QueryConfigOptions) =>
+  Config.all({
+    accountId: options?.accountId ?? Config.string("CLOUDFLARE_ACCOUNT_ID"),
+    apiToken: options?.apiToken ?? Config.redacted("CLOUDFLARE_API_TOKEN"),
+    apiBaseUrl:
+      options?.apiBaseUrl ??
+      Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl)),
+  });
+
+export const queryLayer = <Self>(
+  tag: Context.Service<Self, AnalyticsEngineQueryClient>,
+  definition: AnalyticsEngineQueryDefinition,
+) => Layer.effect(tag, makeQueryClient(definition));
+
+export const queryFetchLayer = <Self>(
+  tag: Context.Service<Self, AnalyticsEngineQueryClient>,
+  definition: AnalyticsEngineQueryDefinition,
+) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
+
+export const queryLayerConfig = <Self>(
+  tag: Context.Service<Self, AnalyticsEngineQueryClient>,
+  config: Config.Config<AnalyticsEngineQueryDefinition> = queryConfig(),
+) =>
+  Layer.effect(
+    tag,
+    Effect.gen(function* () {
+      const definition = yield* config;
+      return yield* makeQueryClient(definition);
+    }),
+  );
+
+export const queryFetchLayerConfig = <Self>(
+  tag: Context.Service<Self, AnalyticsEngineQueryClient>,
+  config: Config.Config<AnalyticsEngineQueryDefinition> = queryConfig(),
+) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
+
+export const layer = <Self>(
+  tag: Context.Service<Self, AnalyticsEngineClient>,
+  definition: LayerOptions,
+) =>
+  Binding.layer(
+    tag,
+    definition.binding,
+    isAnalyticsEngineDataset,
+    makeClient(definition, definition.write),
+    {
+      expected: expectedAnalyticsEngineDataset,
+    },
+  );
+
+export const make = <Id extends string>(id: Id) => Tag<AnalyticsEngineService<Id>>()<Id>(id);
+
+export const makeQuery = <Id extends string>(id: Id) =>
+  QueryTag<AnalyticsEngineQueryService<Id>>()<Id>(id);
+
+export const Tag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, AnalyticsEngineClient>()(id);
+
+    const makeLayer = (definition: LayerOptions) => layer(tag, definition);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+    }) as TagClass<Self, Id>;
+  };
+
+export const QueryTag =
+  <Self>() =>
+  <Id extends string>(id: Id) => {
+    const tag = Context.Service<Self, AnalyticsEngineQueryClient>()(id);
+    const makeLayer = (definition: AnalyticsEngineQueryDefinition) => queryLayer(tag, definition);
+    const makeFetchLayer = (definition: AnalyticsEngineQueryDefinition) =>
+      queryFetchLayer(tag, definition);
+    const makeLayerConfig = (config?: Config.Config<AnalyticsEngineQueryDefinition>) =>
+      queryLayerConfig(tag, config);
+    const makeFetchLayerConfig = (config?: Config.Config<AnalyticsEngineQueryDefinition>) =>
+      queryFetchLayerConfig(tag, config);
+
+    return Object.assign(tag, {
+      id,
+      layer: makeLayer,
+      fetchLayer: makeFetchLayer,
+      layerConfig: makeLayerConfig,
+      fetchLayerConfig: makeFetchLayerConfig,
+    }) as QueryTagClass<Self, Id>;
+  };