@distilled.cloud/axiom 0.30.2 → 1.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/axiom",
-  "version": "0.30.2",
+  "version": "1.0.0-rc.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -9,86 +9,80 @@
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
-  "module": "src/index.ts",
   "files": [
-    "lib",
     "src"
   ],
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
       "bun": "./src/index.ts",
+      "worker": "./src/index.ts",
       "default": "./lib/index.js"
     },
-    "./Category": {
-      "types": "./lib/category.d.ts",
-      "bun": "./src/category.ts",
-      "default": "./lib/category.js"
-    },
-    "./Client": {
-      "types": "./lib/client.d.ts",
-      "bun": "./src/client.ts",
-      "default": "./lib/client.js"
-    },
     "./Credentials": {
       "types": "./lib/credentials.d.ts",
       "bun": "./src/credentials.ts",
+      "worker": "./src/credentials.ts",
       "default": "./lib/credentials.js"
     },
     "./Errors": {
       "types": "./lib/errors.d.ts",
       "bun": "./src/errors.ts",
+      "worker": "./src/errors.ts",
       "default": "./lib/errors.js"
     },
+    "./Traits": {
+      "types": "./lib/traits.d.ts",
+      "bun": "./src/traits.ts",
+      "worker": "./src/traits.ts",
+      "default": "./lib/traits.js"
+    },
+    "./Protocol": {
+      "types": "./lib/protocol.d.ts",
+      "bun": "./src/protocol.ts",
+      "worker": "./src/protocol.ts",
+      "default": "./lib/protocol.js"
+    },
+    "./Retry": {
+      "types": "./lib/retry.d.ts",
+      "bun": "./src/retry.ts",
+      "worker": "./src/retry.ts",
+      "default": "./lib/retry.js"
+    },
     "./edge-ingest": {
       "types": "./lib/edge-ingest.d.ts",
       "bun": "./src/edge-ingest.ts",
+      "worker": "./src/edge-ingest.ts",
       "default": "./lib/edge-ingest.js"
     },
     "./edge-query": {
       "types": "./lib/edge-query.d.ts",
       "bun": "./src/edge-query.ts",
+      "worker": "./src/edge-query.ts",
       "default": "./lib/edge-query.js"
     },
-    "./Retry": {
-      "types": "./lib/retry.d.ts",
-      "bun": "./src/retry.ts",
-      "default": "./lib/retry.js"
-    },
-    "./Sensitive": {
-      "types": "./lib/sensitive.d.ts",
-      "bun": "./src/sensitive.ts",
-      "default": "./lib/sensitive.js"
-    },
-    "./Traits": {
-      "types": "./lib/traits.d.ts",
-      "bun": "./src/traits.ts",
-      "default": "./lib/traits.js"
+    "./*": {
+      "types": "./lib/services/*.d.ts",
+      "bun": "./src/services/*.ts",
+      "worker": "./src/services/*.ts",
+      "default": "./lib/services/*.js"
     }
   },
   "scripts": {
-    "typecheck": "tsc",
     "build": "tsc -b",
-    "fmt": "oxfmt --write src",
-    "lint": "oxlint --fix src",
-    "check": "tsc && oxlint src && oxfmt --check src",
-    "test": "bunx vitest run test --passWithNoTests",
-    "publish:npm": "bun run build && bun publish --access public",
-    "generate": "bun run scripts/generate.ts && oxlint --fix src && oxfmt --write src && oxfmt --write src",
+    "convert": "bun scripts/convert.ts",
+    "generate": "bun scripts/convert.ts && bun scripts/generate.ts",
+    "typecheck": "tsc -p tsconfig.json",
     "specs:fetch": "git submodule update --force --init --recursive --depth=1 specs/docs && git -C specs/docs checkout -- .",
     "specs:update": "git -C specs/docs fetch && git -C specs/docs checkout main && git -C specs/docs pull"
   },
   "dependencies": {
-    "@distilled.cloud/core": "0.30.2"
+    "@distilled.cloud/core": "1.0.0-rc.1",
+    "@effect/platform-bun": ">=4.0.0-beta.102 || >=4.0.0",
+    "effect": ">=4.0.0-beta.102 || >=4.0.0"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.0",
-    "@types/node": "^25.3.5",
-    "dotenv": "^16.5.0",
-    "rolldown": "^1.2.0",
-    "vitest": "^3.2.3"
-  },
-  "peerDependencies": {
-    "effect": ">=4.0.0-beta.100 || >=4.0.0"
+    "@types/bun": "latest",
+    "@types/node": "latest"
   }
 }

package/src/credentials.ts

@@ -1,10 +1,18 @@
-import { ConfigError } from "@distilled.cloud/core/errors";
+/**
+ * Axiom credentials — hand-written.
+ *
+ * API-compatible port of the distilled v0 axiom credentials module: the
+ * `Credentials` service holds an *effect* that resolves the current
+ * credentials on every request (the protocol layer resolves it per request
+ * on the calling fiber).
+ */
 import * as EffectConfig from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
+import { ConfigError } from "@distilled.cloud/core/errors";
 
 /** Default base URL for Axiom Cloud. Self-hosted users can override via AXIOM_URL. */
 export const DEFAULT_API_BASE_URL = "https://api.axiom.co";
@@ -25,6 +33,23 @@ export class Credentials extends Context.Service<
   Effect.Effect<Config>
 >()("AxiomCredentials") {}
 
+/** Layer from a plain API token + optional base URL / org ID. */
+export const fromApiKey = (config: {
+  readonly apiKey: string | Redacted.Redacted<string>;
+  readonly apiBaseUrl?: string;
+  readonly orgId?: string;
+}): Layer.Layer<Credentials> =>
+  Layer.succeed(
+    Credentials,
+    Effect.succeed({
+      apiKey: Redacted.isRedacted(config.apiKey)
+        ? config.apiKey
+        : Redacted.make(config.apiKey),
+      apiBaseUrl: config.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+      orgId: config.orgId,
+    }),
+  );
+
 const envConfig = EffectConfig.all({
   apiToken: EffectConfig.option(EffectConfig.string("AXIOM_TOKEN")),
   apiKey: EffectConfig.option(EffectConfig.string("AXIOM_API_KEY")),
@@ -42,7 +67,7 @@ const envConfig = EffectConfig.all({
  *   regional edge deployments). Defaults to `https://api.axiom.co`.
  * - `AXIOM_ORG_ID` (optional) — organization ID, required for PATs.
  */
-export const CredentialsFromEnv = Layer.succeed(
+export const CredentialsFromEnv: Layer.Layer<Credentials> = Layer.succeed(
   Credentials,
   Effect.gen(function* () {
     const config = yield* envConfig.pipe(

package/src/edge-ingest.ts

@@ -1 +1,6 @@
-export * from "./operations/v1-edge-ingest/index.ts";
+/**
+ * `@distilled.cloud/axiom/edge-ingest` — the v1 edge ingest API
+ * (`ingestToDataset`), served from the same canonical host
+ * (https://api.axiom.co) under the `/v1` prefix.
+ */
+export * from "./services/edge_ingest.ts";

package/src/edge-query.ts

@@ -1 +1,6 @@
-export * from "./operations/v1-edge-query/index.ts";
+/**
+ * `@distilled.cloud/axiom/edge-query` — the v1 edge query API (`queryApl`),
+ * served from the same canonical host (https://api.axiom.co) under the `/v1`
+ * prefix.
+ */
+export * from "./services/edge_query.ts";

package/src/errors.ts

@@ -1,8 +1,11 @@
 /**
  * Axiom-specific error types.
  *
- * Re-exports common HTTP errors from sdk-core and adds Axiom-specific
- * error matching and API error types.
+ * Re-exports the common HTTP errors from core and adds the Axiom fallback
+ * errors. Note the generated service modules additionally define their own
+ * per-status matcher classes (BadRequest/NotFound/…) for the statuses each
+ * operation declares — those share `_tag`s with the core classes here, so
+ * `catchTag` works against either.
  */
 export {
   BadGateway,
@@ -27,7 +30,7 @@ export type { DefaultErrors } from "@distilled.cloud/core/errors";
 import * as Schema from "effect/Schema";
 import * as Category from "@distilled.cloud/core/category";
 
-// Unknown Axiom error - returned when an error code is not recognized
+/** Unknown Axiom error — returned when nothing else matches the failure. */
 export class UnknownAxiomError extends Schema.TaggedErrorClass<UnknownAxiomError>()(
   "UnknownAxiomError",
   {
@@ -37,7 +40,7 @@ export class UnknownAxiomError extends Schema.TaggedErrorClass<UnknownAxiomError
   },
 ).pipe(Category.withServerError) {}
 
-// Schema parse error wrapper
+/** Schema parse error wrapper (kept for v0 surface parity). */
 export class AxiomParseError extends Schema.TaggedErrorClass<AxiomParseError>()(
   "AxiomParseError",
   {

package/src/index.ts

@@ -1,21 +1,43 @@
 /**
- * Axiom SDK for Effect
+ * @distilled.cloud/axiom — Axiom SDK for Effect.
  *
- * The package root re-exports the v2 (control-plane) operations. The v1 edge
- * APIs are available under their own subpath imports:
+ * `./services` is generated by `scripts/generate.ts` from the Smithy models
+ * in `.generated-specs` (written by `scripts/convert.ts` from the three
+ * OpenAPI specs in specs/docs/restapi/versions). Everything else in this
+ * folder is hand-written.
+ *
+ * The v2 control-plane API lives under `Services.v2`; the v1 edge APIs are
+ * also available under their own subpath imports:
  *
  * @example
- * \`\`\`ts
- * import * as Operations from "@distilled.cloud/axiom";
+ * ```ts
+ * import * as Axiom from "@distilled.cloud/axiom";
  * import * as EdgeIngest from "@distilled.cloud/axiom/edge-ingest";
  * import * as EdgeQuery from "@distilled.cloud/axiom/edge-query";
- * \`\`\`
+ *
+ * const datasets = yield* Axiom.Services.v2.getDatasets({});
+ * ```
  */
 export * from "./credentials.ts";
-export * as Category from "./category.ts";
+export * from "./errors.ts";
 export * as T from "./traits.ts";
+export {
+  AxiomProtocol,
+  stripNulls,
+  type AxiomOpError,
+  type AxiomOpContext,
+} from "./protocol.ts";
 export * as Retry from "./retry.ts";
-export { API } from "./client.ts";
-export * from "./errors.ts";
-export { SensitiveString, SensitiveNullableString } from "./sensitive.ts";
-export * from "./operations/index.ts";
+export * as Services from "./services/index.ts";
+// v0-parity surface: the v2 control-plane operations live on the package
+// root (edge-ingest / edge-query stay behind their subpath exports).
+// The service-local typed error classes shadow the same-named shared ones
+// from ./errors.ts — the ops actually raise the service-local classes.
+export * from "./services/v2.ts";
+export {
+  BadRequest,
+  Conflict,
+  Forbidden,
+  NotFound,
+  UnprocessableEntity,
+} from "./services/v2.ts";

package/src/protocol.ts

@@ -0,0 +1,111 @@
+/**
+ * AxiomProtocol — hand-written.
+ *
+ * Axiom speaks plain bearer-authenticated JSON REST (no response envelope),
+ * so the whole protocol is one `makeRestProtocol` call from
+ * `core/protocol-rest`:
+ *
+ *   request:  credentials → `Authorization: Bearer <apiKey>` (+ optional
+ *             `X-Axiom-Org-ID` for Personal Access Tokens) + base URL
+ *             (default https://api.axiom.co), resolved from the calling
+ *             fiber on every request
+ *
+ *   response: 2xx JSON is the payload, with explicit JSON `null` properties
+ *             recursively dropped first ({@link stripNulls} — Axiom's Go
+ *             backend serializes nil slices/omitted optionals as `null`);
+ *             non-2xx bodies map to the operation's typed error classes by
+ *             status, then the shared HTTP-status classes, then
+ *             {@link UnknownAxiomError}. Axiom returns two error envelope
+ *             shapes — `{ code, message }` (control-plane / edge-ingest) and
+ *             `{ error, message }` (edge-query) — unified by a lenient
+ *             extractor; the HTTP status stays the authoritative signal.
+ */
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as HttpClientError from "effect/unstable/http/HttpClientError";
+import type * as API from "@distilled.cloud/core/api";
+import {
+  makeRestProtocol,
+  type RestErrorEnvelope,
+} from "@distilled.cloud/core/protocol-rest";
+import type { API_ERRORS, ConfigError } from "@distilled.cloud/core/errors";
+import { Credentials, type Config } from "./credentials.ts";
+import { UnknownAxiomError } from "./errors.ts";
+
+/**
+ * Error channel shared by every generated Axiom operation. Generated service
+ * files annotate operations with `API.OperationMethod<I, O, AxiomOpError,
+ * AxiomOpContext>` explicitly so the compiler never infers these back out of
+ * the schema generics.
+ */
+export type AxiomOpError =
+  | InstanceType<(typeof API_ERRORS)[number]>
+  | UnknownAxiomError
+  | ConfigError
+  | HttpClientError.HttpClientError;
+
+/** Context (requirements) shared by every generated Axiom operation. */
+export type AxiomOpContext = Credentials | HttpClient.HttpClient;
+
+/**
+ * Axiom's backend (Go) serializes nil slices and omitted optional fields as
+ * JSON `null`. The generated output schemas model these as optional members
+ * (value or absent), so `null` trips decoding. Recursively drop explicit
+ * `null` properties before decoding so optional fields are treated as
+ * absent. Keys that are genuinely nullable in the API are patched to
+ * nullable in the spec — this hook exists for the far more common "Go nil
+ * slice" case.
+ */
+export const stripNulls = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map(stripNulls);
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      if (v === null) continue;
+      out[k] = stripNulls(v);
+    }
+    return out;
+  }
+  return value;
+};
+
+/**
+ * Unify Axiom's two error envelope shapes (`{ code, message }` and
+ * `{ error, message }`, some endpoints plain `{ message }`) into one
+ * `{ code?, message? }` pair — v0 semantics: `message ?? error`,
+ * `code ?? error`.
+ */
+const errorEnvelope = (body: unknown): RestErrorEnvelope | undefined => {
+  if (body === null || typeof body !== "object") return undefined;
+  const b = body as Record<string, unknown>;
+  const error = typeof b.error === "string" ? b.error : undefined;
+  const code =
+    typeof b.code === "string" || typeof b.code === "number" ? b.code : error;
+  const message = typeof b.message === "string" ? b.message : error;
+  return { code, message };
+};
+
+export const AxiomProtocol: Layer.Layer<API.Protocol> =
+  makeRestProtocol<Config>({
+    // The Credentials service holds an effect — resolving it here (per
+    // request, on the calling fiber) picks up context-provided credentials.
+    credentials: Effect.gen(function* () {
+      const resolve = yield* Credentials;
+      return yield* resolve;
+    }),
+    baseUrl: (creds) => creds.apiBaseUrl,
+    headers: (creds) => ({
+      Authorization: `Bearer ${Redacted.value(creds.apiKey)}`,
+      ...(creds.orgId ? { "X-Axiom-Org-ID": creds.orgId } : {}),
+    }),
+    errorEnvelope,
+    transformResponse: stripNulls,
+    unknownError: ({ code, message, body }) =>
+      new UnknownAxiomError({
+        code: typeof code === "number" ? String(code) : code,
+        message,
+        body,
+      }),
+  });

package/src/retry.ts

@@ -1,10 +1,9 @@
 /**
  * Axiom retry configuration.
  *
- * Defines the per-SDK `Retry` Context.Service tag that
- * `packages/axiom/src/client.ts` wires into `makeAPI`. Callers can
- * install a blanket retry policy at the layer level and have every
- * Axiom API call below it pick it up:
+ * Defines the per-SDK `Retry` Context.Service tag that generated operations
+ * wire into `API.make`. Callers can install a blanket retry policy at the
+ * layer level and have every Axiom API call below it pick it up:
  *
  * @example
  * ```ts

package/src/services/edge_ingest.ts

@@ -0,0 +1,124 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/docs restapi/versions). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  AxiomProtocol,
+  type AxiomOpError,
+  type AxiomOpContext,
+} from "../protocol.ts";
+import { UnknownAxiomError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { AxiomOpError, AxiomOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedErrorClass<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }),
+    [{ status: 400 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedErrorClass<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }),
+    [{ status: 404 }],
+  ) {}
+
+export class UnprocessableEntity
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedErrorClass<UnprocessableEntity>()(
+      "UnprocessableEntity",
+      {
+        code: S.Number,
+        message: S.String,
+      },
+    ),
+    [{ status: 422 }],
+  ) {}
+
+export interface IngestToDatasetRequest {
+  dataset_id: string;
+  /** The name of the field to use as the timestamp. If not specified, the timestamp will be the time the event was received by Axiom. */
+  timestamp_field?: string;
+  /** The date-time format of the timestamp field. The reference time is `Mon Jan 2 15:04:05 -0700 MST 2006`, as specified in https://pkg.go.dev/time/?tab=doc#Parse */
+  timestamp_format?: string;
+  /** The delimiter to use when parsing CSV data. If not specified, the default delimiter is `,`. */
+  csv_delimiter?: string;
+  body: string;
+}
+export const IngestToDatasetRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dataset_id: S.String.pipe(T.Label()),
+    timestamp_field: S.optional(S.String.pipe(T.Query("timestamp-field"))),
+    timestamp_format: S.optional(S.String.pipe(T.Query("timestamp-format"))),
+    csv_delimiter: S.optional(S.String.pipe(T.Query("csv-delimiter"))),
+    body: S.String.pipe(T.HttpBody()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v1/datasets/{dataset_id}/ingest",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IngestToDatasetRequest",
+}) as any as S.Schema<IngestToDatasetRequest>;
+
+export interface IngestFailure {
+  error: string;
+  timestamp: string;
+}
+export const IngestFailure = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    error: S.String,
+    timestamp: S.String,
+  }),
+).annotate({ identifier: "IngestFailure" }) as any as S.Schema<IngestFailure>;
+
+export type IngestStatusFailuresList = Array<IngestFailure>;
+export const IngestStatusFailuresList = /*@__PURE__*/ S.Array(
+  IngestFailure,
+) as any as S.Schema<IngestStatusFailuresList>;
+
+export interface IngestStatus {
+  blocksCreated: number;
+  failed: number;
+  failures?: IngestStatusFailuresList;
+  ingested: number;
+  processedBytes: number;
+  walLength: number;
+}
+export const IngestStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    blocksCreated: S.Number,
+    failed: S.Number,
+    failures: S.optional(IngestStatusFailuresList),
+    ingested: S.Number,
+    processedBytes: S.Number,
+    walLength: S.Number,
+  }),
+).annotate({ identifier: "IngestStatus" }) as any as S.Schema<IngestStatus>;
+
+export type IngestToDatasetError =
+  | BadRequest
+  | NotFound
+  | UnprocessableEntity
+  | AxiomOpError;
+export const ingestToDataset: API.OperationMethod<
+  IngestToDatasetRequest,
+  IngestStatus,
+  IngestToDatasetError,
+  AxiomOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IngestToDatasetRequest,
+  output: IngestStatus,
+  errors: [BadRequest, NotFound, UnprocessableEntity, UnknownAxiomError],
+  protocol: AxiomProtocol,
+  retry: Retry.Retry,
+}));