@hodeinavarro/odoo-rpc-ts 0.2.0

package/src/combinators/retryOnSessionExpired.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import type { CookieLoginError, CookieSessionService } from "../session/cookie.ts";
+
+/**
+ * Opt-in recovery for a single `SessionExpiredError`: invalidate the cached
+ * session, re-authenticate once, then retry `effect` exactly once. A second
+ * failure — including another `SessionExpiredError` — propagates untouched.
+ *
+ * Deliberately policy-free: no backoff, no retry count beyond one. Auto-relogin
+ * is NOT wired into the transport (AGENTS.md decision); callers opt in here so
+ * the session-expiry signal stays observable by default.
+ */
+export const retryOnSessionExpired = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  session: CookieSessionService,
+): Effect.Effect<A, E | CookieLoginError, R> =>
+  Effect.catchIf(
+    effect,
+    (error): error is Extract<E, { readonly _tag: "SessionExpiredError" }> =>
+      typeof error === "object" &&
+      error !== null &&
+      "_tag" in error &&
+      (error as { readonly _tag: unknown })._tag === "SessionExpiredError",
+    () => session.invalidate.pipe(Effect.andThen(session.login), Effect.andThen(effect)),
+  );

package/src/commands.ts

@@ -0,0 +1,112 @@
+/**
+ * Typed constructors for Odoo's x2many write commands — the special 3-element
+ * triples an {@link https://www.odoo.com/documentation | One2many}/Many2many
+ * field expects inside a `create`/`write` `values` payload.
+ *
+ * Each command is `[code, id, payload]`: the first element is the integer that
+ * identifies the command, the second is either the target record id (update,
+ * delete, unlink, link) or `0`, and the third is either the `values` to write
+ * (create, update), the new `ids` list (set), or `0`. Straight port of Odoo's
+ * `Command` namespace (`odoo/fields.py` 16.x, `odoo/orm/commands.py` 19.x — the
+ * emitted triples are identical across 16–19).
+ *
+ * GOTCHA: over RPC only the literal triples travel — never the Python `Command`
+ * enum members or constant names. These constructors return exactly those
+ * literal triples, so a value built here is wire-ready as-is.
+ */
+
+/** Field-name → value map written by the create/update commands. */
+export type CommandValues = { readonly [field: string]: unknown };
+
+/** `create(values)` → `[0, 0, values]` — create a comodel record and link it. */
+export type CreateCommand = readonly [0, 0, CommandValues];
+
+/** `update(id, values)` → `[1, id, values]` — write `values` on the related record. */
+export type UpdateCommand = readonly [1, number, CommandValues];
+
+/** `delete(id)` → `[2, id, 0]` — unlink and delete the related record from the db. */
+export type DeleteCommand = readonly [2, number, 0];
+
+/** `unlink(id)` → `[3, id, 0]` — drop the relation, keep (or cascade) the record. */
+export type UnlinkCommand = readonly [3, number, 0];
+
+/** `link(id)` → `[4, id, 0]` — add a relation to an existing record. */
+export type LinkCommand = readonly [4, number, 0];
+
+/** `clear()` → `[5, 0, 0]` — unlink every related record. */
+export type ClearCommand = readonly [5, 0, 0];
+
+/** `set(ids)` → `[6, 0, ids]` — replace all relations with exactly `ids`. */
+export type SetCommand = readonly [6, 0, ReadonlyArray<number>];
+
+/** Any single x2many write command triple. */
+export type CommandTuple =
+  | CreateCommand
+  | UpdateCommand
+  | DeleteCommand
+  | UnlinkCommand
+  | LinkCommand
+  | ClearCommand
+  | SetCommand;
+
+/** A list of x2many commands, as it sits inside a `values` payload. */
+export type X2ManyCommands = ReadonlyArray<CommandTuple>;
+
+/**
+ * The `Command` namespace — one constructor per x2many command. Grouped as a
+ * frozen object of standalone functions (no `enum`/`namespace`, per
+ * `erasableSyntaxOnly`); each carries the wire encoding in its return type so
+ * the literal command code survives inference.
+ */
+export const Command = {
+  /**
+   * Create new comodel records from `values` and link them to `self`.
+   *
+   * Wire: `[0, 0, values]`.
+   */
+  create: (values: CommandValues): CreateCommand => [0, 0, values],
+
+  /**
+   * Write `values` on the related record `id`.
+   *
+   * Wire: `[1, id, values]`.
+   */
+  update: (id: number, values: CommandValues): UpdateCommand => [1, id, values],
+
+  /**
+   * Remove the related record `id` from the database and drop its relation.
+   *
+   * Wire: `[2, id, 0]`.
+   */
+  delete: (id: number): DeleteCommand => [2, id, 0],
+
+  /**
+   * Remove the relation to record `id` without deleting it (One2many may
+   * cascade-delete when the inverse is `ondelete='cascade'`).
+   *
+   * Wire: `[3, id, 0]`.
+   */
+  unlink: (id: number): UnlinkCommand => [3, id, 0],
+
+  /**
+   * Add a relation between `self` and the existing record `id`.
+   *
+   * Wire: `[4, id, 0]`.
+   */
+  link: (id: number): LinkCommand => [4, id, 0],
+
+  /**
+   * Remove all relations (equivalent to `unlink` on every related record).
+   *
+   * Wire: `[5, 0, 0]`.
+   */
+  clear: (): ClearCommand => [5, 0, 0],
+
+  /**
+   * Replace the current relations with exactly `ids` (unlink removed, link
+   * added).
+   *
+   * Wire: `[6, 0, ids]`.
+   */
+  set: (ids: ReadonlyArray<number>): SetCommand => [6, 0, ids],
+} as const;

package/src/config.ts

@@ -0,0 +1,110 @@
+import { Config, Effect, Option, Schema, SchemaIssue, type Redacted } from "effect";
+
+/**
+ * How the client authenticates. A tagged union so downstream auth layers
+ * branch on `_tag` rather than probing which secret is present. Both secrets
+ * are `Redacted` — never logged, never serialized.
+ *
+ * - `ApiKey` — server-to-server; the API key is sent as the password on the
+ *   web/JSON-RPC routes, or as a bearer token on JSON-2.
+ * - `Password` — a login password (only valid for accounts without 2FA).
+ */
+export type OdooCredentials =
+  | {
+      readonly _tag: "ApiKey";
+      readonly username: string;
+      readonly apiKey: Redacted.Redacted<string>;
+    }
+  | {
+      readonly _tag: "Password";
+      readonly username: string;
+      readonly password: Redacted.Redacted<string>;
+    };
+
+/** Fully-resolved client configuration. No field has a default: zero assumptions. */
+export interface OdooConfig {
+  readonly url: URL;
+  readonly db: string;
+  readonly credentials: OdooCredentials;
+}
+
+/**
+ * A config validation failure carrying a caller-selected diagnostic value.
+ * Secret-bearing inputs must pass a fixed redacted placeholder. v4's
+ * `ConfigError` wraps a `SchemaError` (data found but invalid) — the analogue
+ * of v3's `ConfigError.InvalidData`.
+ */
+const invalidData = (value: unknown, message: string): Config.ConfigError =>
+  new Config.ConfigError(
+    new Schema.SchemaError(new SchemaIssue.InvalidValue(Option.some(value), { message })),
+  );
+
+/**
+ * Parse and validate the `ODOO_URL` value: must be a well-formed absolute URL
+ * without userinfo, query parameters, or a fragment, and must be `https`
+ * unless it targets localhost / a loopback address. TLS is never silently
+ * disabled.
+ */
+const parseUrl = (raw: string): Effect.Effect<URL, Config.ConfigError> => {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    return Effect.fail(invalidData("<redacted>", "ODOO_URL is not a valid absolute URL"));
+  }
+
+  if (url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") {
+    return Effect.fail(
+      invalidData(
+        "<redacted>",
+        "ODOO_URL must not contain userinfo, query parameters, or a fragment",
+      ),
+    );
+  }
+
+  const isLoopback =
+    url.hostname === "localhost" ||
+    url.hostname === "127.0.0.1" ||
+    url.hostname === "[::1]" ||
+    url.hostname === "::1";
+
+  if (url.protocol !== "https:" && !isLoopback) {
+    return Effect.fail(
+      invalidData("<redacted>", "ODOO_URL must use https unless it targets a loopback host"),
+    );
+  }
+
+  return Effect.succeed(url);
+};
+
+const urlConfig: Config.Config<URL> = Config.string("URL").pipe(Config.mapOrFail(parseUrl));
+
+const apiKeyCredentials: Config.Config<OdooCredentials> = Config.all({
+  username: Config.string("USERNAME"),
+  apiKey: Config.redacted("API_KEY"),
+}).pipe(Config.map((c) => ({ _tag: "ApiKey" as const, ...c })));
+
+const passwordCredentials: Config.Config<OdooCredentials> = Config.all({
+  username: Config.string("USERNAME"),
+  password: Config.redacted("PASSWORD"),
+}).pipe(Config.map((c) => ({ _tag: "Password" as const, ...c })));
+
+/**
+ * Prefer an API key when `ODOO_API_KEY` is present; otherwise fall back to a
+ * login password (`ODOO_PASSWORD`). If neither secret is set, config resolution
+ * fails loudly — there is no anonymous default.
+ */
+const credentialsConfig: Config.Config<OdooCredentials> = apiKeyCredentials.pipe(
+  Config.orElse(() => passwordCredentials),
+);
+
+/**
+ * The client configuration, read from environment (or any `ConfigProvider`)
+ * under the `ODOO_` prefix: `ODOO_URL`, `ODOO_DB`, `ODOO_USERNAME`, and one of
+ * `ODOO_API_KEY` / `ODOO_PASSWORD`.
+ */
+export const OdooConfig: Config.Config<OdooConfig> = Config.all({
+  url: urlConfig,
+  db: Config.string("DB"),
+  credentials: credentialsConfig,
+}).pipe(Config.nested("ODOO"));

package/src/domain.ts

@@ -0,0 +1,91 @@
+/**
+ * Odoo search domains, in their native Polish-prefix form. A domain is a flat
+ * list mixing leaf conditions and the operators `&` (and), `|` (or), `!` (not).
+ * Adjacent leaves with no operator between them are implicitly ANDed by Odoo.
+ *
+ * We keep the leaf pragmatic — `[field, operator, value]` — rather than trying
+ * to type Odoo's full operator/value matrix, which drifts across versions.
+ */
+
+/** Domain boolean operators, in Odoo's prefix notation. */
+export type DomainOperator = "&" | "|" | "!";
+
+/** A single condition: `[field, operator, value]`. */
+export type DomainLeaf = readonly [string, string, unknown];
+
+/** One token of a domain: either an operator or a leaf. */
+export type DomainItem = DomainOperator | DomainLeaf;
+
+/** A complete Odoo domain. */
+export type Domain = ReadonlyArray<DomainItem>;
+
+const isLeaf = (item: DomainItem): item is DomainLeaf => Array.isArray(item);
+
+/**
+ * Rewrite a domain into a single, fully-explicit prefix expression: every
+ * implicit AND between adjacent leaves is made explicit with a leading `&`,
+ * so the result is one well-formed expression that can be safely nested inside
+ * a larger one. Port of Odoo's `expression.normalize_domain`.
+ */
+export const normalizeDomain = (domain: Domain): Domain => {
+  if (domain.length === 0) {
+    return [];
+  }
+
+  const result: Array<DomainItem> = [];
+  // Number of expressions still expected to complete the current subtree.
+  let expected = 1;
+
+  for (const token of domain) {
+    if (expected === 0) {
+      // A previous expression already completed; an extra one means an
+      // implicit AND — make it explicit at the front.
+      result.unshift("&");
+      expected = 1;
+    }
+    result.push(token);
+    if (isLeaf(token)) {
+      expected -= 1;
+    } else if (token === "&" || token === "|") {
+      expected += 1;
+    }
+    // "!" is unary: it consumes and produces exactly one expression, so the
+    // expected count is unchanged.
+  }
+
+  return result;
+};
+
+/**
+ * Fold several sub-domains together under one binary operator, normalizing
+ * each first. Empty sub-domains are dropped (they constrain nothing). Zero
+ * survivors yields the empty domain; one survivor is returned as-is.
+ */
+const combine = (op: "&" | "|", domains: ReadonlyArray<Domain>): Domain => {
+  const parts = domains.map(normalizeDomain).filter((d) => d.length > 0);
+
+  if (parts.length === 0) {
+    return [];
+  }
+  if (parts.length === 1) {
+    return parts[0]!;
+  }
+
+  const prefix: Array<DomainItem> = Array.from({ length: parts.length - 1 }, () => op);
+  return [...prefix, ...parts.flat()];
+};
+
+/** Conjoin sub-domains: every one must match. */
+export const AND = (...domains: ReadonlyArray<Domain>): Domain => combine("&", domains);
+
+/** Disjoin sub-domains: at least one must match. */
+export const OR = (...domains: ReadonlyArray<Domain>): Domain => combine("|", domains);
+
+/** Negate a domain. */
+export const NOT = (domain: Domain): Domain => {
+  const normalized = normalizeDomain(domain);
+  if (normalized.length === 0) {
+    return [];
+  }
+  return ["!", ...normalized];
+};

package/src/errors/auth.ts

@@ -0,0 +1,28 @@
+import { Data } from "effect";
+
+/**
+ * Why authentication failed. Distinct reasons so callers can branch without
+ * parsing messages:
+ *
+ * - `invalid-credentials` — wrong username/password or db.
+ * - `mfa-pending` — credentials accepted but a second factor is required
+ *   before a usable session exists.
+ * - `api-key-expired-or-invalid` — the API key was rejected.
+ * - `totp-rpc-password` — hint: this account has 2FA enabled, so its login
+ *   password cannot be used for RPC; an API key (used as the password) is
+ *   required instead.
+ */
+export type OdooAuthReason =
+  | "invalid-credentials"
+  | "mfa-pending"
+  | "api-key-expired-or-invalid"
+  | "totp-rpc-password";
+
+/**
+ * Authentication did not yield a usable session. Carries a structured
+ * {@link OdooAuthReason} rather than a free-text message.
+ */
+export class OdooAuthenticationError extends Data.TaggedError("OdooAuthenticationError")<{
+  readonly reason: OdooAuthReason;
+  readonly message: string;
+}> {}

package/src/errors/index.ts

@@ -0,0 +1,50 @@
+/**
+ * The complete error taxonomy for @hodeinavarro/odoo-rpc-ts. Every failure
+ * the client can produce is one of these tagged errors — nothing throws, and
+ * there is no blanket error type. See AGENTS.md § Error taxonomy.
+ */
+
+export { OdooTransportError, type RequestInfo, type TransportErrorKind } from "./transport.ts";
+export { OdooAuthenticationError, type OdooAuthReason } from "./auth.ts";
+export { SessionExpiredError } from "./session.ts";
+export { SchemaDriftError } from "./schema.ts";
+export { ProtocolUnsupportedError, type OdooProtocol } from "./protocol.ts";
+export {
+  OdooServerError,
+  OdooAccessError,
+  OdooValidationError,
+  OdooMissingError,
+  OdooUserError,
+  OdooLockError,
+  serverFaultFields,
+  type OdooServerFault,
+} from "./server.ts";
+export { mapServerFault, type RawServerFault, type FaultCallSite } from "./mapFault.ts";
+
+import type { OdooTransportError } from "./transport.ts";
+import type { OdooAuthenticationError } from "./auth.ts";
+import type { SessionExpiredError } from "./session.ts";
+import type { SchemaDriftError } from "./schema.ts";
+import type { ProtocolUnsupportedError } from "./protocol.ts";
+import type { OdooServerFault } from "./server.ts";
+
+/** Transport / wire-layer failures. */
+export type OdooTransportFailure = OdooTransportError;
+
+/** Everything about establishing or keeping a usable session. */
+export type OdooAuthFailure = OdooAuthenticationError | SessionExpiredError;
+
+/** Boundary-decoding failures. */
+export type OdooDecodeFailure = SchemaDriftError;
+
+/**
+ * The complete union of every error this client can fail with. Callers narrow
+ * with `Effect.catchTag` / `catchTags`.
+ */
+export type OdooError =
+  | OdooTransportError
+  | OdooAuthenticationError
+  | SessionExpiredError
+  | SchemaDriftError
+  | ProtocolUnsupportedError
+  | OdooServerFault;

package/src/errors/mapFault.ts

@@ -0,0 +1,92 @@
+import { OdooAuthenticationError } from "./auth.ts";
+import {
+  OdooAccessError,
+  OdooLockError,
+  OdooMissingError,
+  OdooServerError,
+  OdooUserError,
+  OdooValidationError,
+  type OdooServerFault,
+} from "./server.ts";
+
+/**
+ * The raw fault as surfaced by a transport choke point, before mapping. Only
+ * `name` and `message` are guaranteed by Odoo; the rest may be absent and are
+ * normalized to empty by the transport before reaching here.
+ */
+export interface RawServerFault {
+  readonly name: string;
+  readonly message: string;
+  readonly arguments: ReadonlyArray<unknown>;
+  readonly context: Record<string, unknown>;
+  readonly debug?: string | undefined;
+}
+
+/** The call site, threaded through so faults carry where they came from. */
+export interface FaultCallSite {
+  readonly model?: string | undefined;
+  readonly method?: string | undefined;
+}
+
+/**
+ * Concrete constructors for the mapped subtypes, keyed by dotted Python name.
+ * Any name absent from this table falls through to {@link OdooServerError},
+ * which preserves the raw `name` verbatim.
+ */
+const byName: Record<string, new (fields: ConstructorFields) => OdooServerFault> = {
+  "odoo.exceptions.AccessError": OdooAccessError,
+  "odoo.exceptions.ValidationError": OdooValidationError,
+  "odoo.exceptions.MissingError": OdooMissingError,
+  "odoo.exceptions.UserError": OdooUserError,
+  "odoo.exceptions.RedirectWarning": OdooUserError,
+  "odoo.exceptions.Warning": OdooUserError,
+  "odoo.exceptions.LockError": OdooLockError,
+};
+
+interface ConstructorFields {
+  readonly name: string;
+  readonly message: string;
+  readonly arguments: ReadonlyArray<unknown>;
+  readonly context: Record<string, unknown>;
+  readonly debug?: string;
+  readonly model?: string;
+  readonly method?: string;
+}
+
+/**
+ * Map a raw Odoo fault to exactly one tagged subtype. Shared by all three
+ * transports' choke points so mapping lives in one place. Unknown names fall
+ * back to {@link OdooServerError} with `name` preserved.
+ *
+ * GOTCHA: `odoo.exceptions.AccessDenied` is *authentication* (bad password or
+ * API key — XML-RPC fault 3, distinct from AccessError's fault 4), so it maps
+ * to {@link OdooAuthenticationError}, not to a server fault. Accounts with
+ * TOTP enabled reject passwords over RPC entirely, hence the reason hint.
+ */
+export const mapServerFault = (
+  fault: RawServerFault,
+  site: FaultCallSite = {},
+): OdooServerFault | OdooAuthenticationError => {
+  if (fault.name === "odoo.exceptions.AccessDenied") {
+    return new OdooAuthenticationError({
+      reason: "invalid-credentials",
+      message: fault.message,
+    });
+  }
+
+  const Ctor = byName[fault.name] ?? OdooServerError;
+
+  // Build with exactOptionalPropertyTypes: only attach optional keys when
+  // actually present, never as explicit `undefined`.
+  const fields: ConstructorFields = {
+    name: fault.name,
+    message: fault.message,
+    arguments: fault.arguments,
+    context: fault.context,
+    ...(fault.debug !== undefined ? { debug: fault.debug } : {}),
+    ...(site.model !== undefined ? { model: site.model } : {}),
+    ...(site.method !== undefined ? { method: site.method } : {}),
+  };
+
+  return new Ctor(fields);
+};

package/src/errors/protocol.ts

@@ -0,0 +1,19 @@
+import { Data } from "effect";
+
+/**
+ * The wire protocols this client can speak. `json-2` is the Odoo 19+
+ * `/json/2/<model>/<method>` bearer API; `json-rpc` is `/jsonrpc` →
+ * `execute_kw`; `web` is the cookie-session `/web/dataset/call_kw` route.
+ */
+export type OdooProtocol = "json-rpc" | "json-2" | "web";
+
+/**
+ * The requested protocol is not available on the resolved server version —
+ * e.g. asking a 16.0 server for JSON-2. Raised by the version resolver seam
+ * so callers fail fast with a typed reason instead of interpreting a raw 404.
+ */
+export class ProtocolUnsupportedError extends Data.TaggedError("ProtocolUnsupportedError")<{
+  readonly protocol: OdooProtocol;
+  readonly serverVersion: string;
+  readonly message: string;
+}> {}

package/src/errors/schema.ts

@@ -0,0 +1,18 @@
+import { Data } from "effect";
+import type { Schema } from "effect";
+
+/**
+ * A response reached us intact at the transport layer but did not match the
+ * schema we decode it through — the server's wire shape drifted (a version
+ * quirk, an unexpected null, a renamed field). We fail loudly with the raw
+ * payload attached rather than casting past the mismatch.
+ *
+ * `payload` is the undecoded value exactly as received, for diagnosis.
+ * `cause` is the `effect/Schema` `SchemaError` describing the mismatch (v4;
+ * formerly v3's `ParseResult.ParseError`).
+ */
+export class SchemaDriftError extends Data.TaggedError("SchemaDriftError")<{
+  readonly context: string;
+  readonly payload: unknown;
+  readonly cause: Schema.SchemaError;
+}> {}

package/src/errors/server.ts

@@ -0,0 +1,79 @@
+import { Schema } from "effect";
+
+/**
+ * Fields shared by every Odoo server fault. These are wire-decoded (the fault
+ * payload is normalized at each transport's choke point), so the classes use
+ * `Schema.TaggedErrorClass` rather than `Data.TaggedError`.
+ *
+ * - `name` — the raw Python exception name (e.g. `odoo.exceptions.AccessError`),
+ *   preserved verbatim so nothing is lost even on the fallback path.
+ * - `message` — the human-facing message Odoo produced.
+ * - `arguments` — the exception's positional args, undecoded.
+ * - `context` — the Odoo `context` dict in effect at the call, if surfaced.
+ * - `debug` — the server traceback, when the server includes one.
+ * - `model` / `method` — the call site, threaded in by the choke point.
+ */
+export const serverFaultFields = {
+  name: Schema.String,
+  message: Schema.String,
+  arguments: Schema.Array(Schema.Unknown),
+  context: Schema.Record(Schema.String, Schema.Unknown),
+  debug: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  method: Schema.optional(Schema.String),
+} as const;
+
+/**
+ * Any Odoo application-level fault whose Python name we do not map to a more
+ * specific subtype. The raw `name` is preserved so callers can still branch on
+ * it, and no information is discarded.
+ */
+export class OdooServerError extends Schema.TaggedErrorClass<OdooServerError>()(
+  "OdooServerError",
+  serverFaultFields,
+) {}
+
+/** `odoo.exceptions.AccessError` / `AccessDenied` — permission denied. */
+export class OdooAccessError extends Schema.TaggedErrorClass<OdooAccessError>()(
+  "OdooAccessError",
+  serverFaultFields,
+) {}
+
+/** `odoo.exceptions.ValidationError` — a constraint/validation was violated. */
+export class OdooValidationError extends Schema.TaggedErrorClass<OdooValidationError>()(
+  "OdooValidationError",
+  serverFaultFields,
+) {}
+
+/** `odoo.exceptions.MissingError` — a referenced record no longer exists. */
+export class OdooMissingError extends Schema.TaggedErrorClass<OdooMissingError>()(
+  "OdooMissingError",
+  serverFaultFields,
+) {}
+
+/** `odoo.exceptions.UserError` — a deliberate, user-facing business error. */
+export class OdooUserError extends Schema.TaggedErrorClass<OdooUserError>()(
+  "OdooUserError",
+  serverFaultFields,
+) {}
+
+/**
+ * `odoo.exceptions.LockError` — concurrent-update / serialization lock failure
+ * (surfaced as a distinct exception on Odoo 19+).
+ */
+export class OdooLockError extends Schema.TaggedErrorClass<OdooLockError>()(
+  "OdooLockError",
+  serverFaultFields,
+) {}
+
+/**
+ * The union of every server-fault subtype. `mapServerFault` narrows a raw
+ * fault to exactly one of these.
+ */
+export type OdooServerFault =
+  | OdooServerError
+  | OdooAccessError
+  | OdooValidationError
+  | OdooMissingError
+  | OdooUserError
+  | OdooLockError;

package/src/errors/session.ts

@@ -0,0 +1,12 @@
+import { Data } from "effect";
+
+/**
+ * The cookie-based web session is no longer valid (JSON-RPC error code 100 /
+ * `odoo.http.SessionExpiredException`). The `session_id` must be re-minted via
+ * `/web/session/authenticate` before retrying. Distinct from
+ * {@link OdooAuthenticationError} because the credentials themselves may still
+ * be good — only the session died.
+ */
+export class SessionExpiredError extends Data.TaggedError("SessionExpiredError")<{
+  readonly message: string;
+}> {}