@incorta/sdk 1.8.0

package/dist/index.js

@@ -0,0 +1,1012 @@
+// src/core/config.ts
+import { createIncortaAuth } from "@incorta/auth";
+
+// src/core/errors.ts
+var CODE_PATTERN = /^\s*(INC_\d+)\s*:\s*([\s\S]*)$/;
+var BODY_LIMIT = 2e3;
+var IncortaError = class extends Error {
+  constructor(message) {
+    super(`[incorta-sdk] ${message}`);
+    this.name = "IncortaError";
+  }
+};
+var IncortaConfigError = class extends IncortaError {
+  constructor(message) {
+    super(message);
+    this.name = "IncortaConfigError";
+  }
+};
+var IncortaAuthRequiredError = class extends IncortaError {
+  constructor(message = "No Incorta session on this request. Sign the user in first \u2014 mount `client.auth.handler` and redirect to its /login route, or wrap the app in `client.auth.gate`.") {
+    super(message);
+    this.name = "IncortaAuthRequiredError";
+  }
+};
+var IncortaSessionExpiredError = class extends IncortaError {
+  constructor(expiredAt) {
+    super(
+      `The Incorta access token on this client expired at ${new Date(expiredAt).toISOString()}. Re-read the session (client.forRequest(request)) to get a refreshed token.`
+    );
+    this.expiredAt = expiredAt;
+    this.name = "IncortaSessionExpiredError";
+  }
+  expiredAt;
+};
+var IncortaConnectionError = class extends IncortaError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "IncortaConnectionError";
+  }
+  cause;
+};
+var IncortaTimeoutError = class extends IncortaConnectionError {
+  constructor(message) {
+    super(message);
+    this.name = "IncortaTimeoutError";
+  }
+};
+var IncortaApiError = class extends IncortaError {
+  /** HTTP status code of the response. */
+  statusCode;
+  /** Incorta error code such as `"INC_09030108"`, when the response carried one. */
+  code;
+  /** Human-readable message with the `INC_` prefix stripped. */
+  detail;
+  /** Raw response text, truncated for readability. */
+  responseBody;
+  /** The request URL. Never carries credentials — the token travels in a header. */
+  url;
+  constructor(statusCode, detail, options = {}) {
+    const prefix = options.code ? `[${options.code}] ` : "";
+    super(`HTTP ${statusCode}: ${prefix}${detail}`);
+    this.name = "IncortaApiError";
+    this.statusCode = statusCode;
+    this.code = options.code;
+    this.detail = detail;
+    this.responseBody = (options.responseBody ?? "").slice(0, BODY_LIMIT);
+    this.url = options.url;
+  }
+};
+var AuthenticationError = class extends IncortaApiError {
+  constructor(...args) {
+    super(...args);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionDeniedError = class extends IncortaApiError {
+  constructor(...args) {
+    super(...args);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends IncortaApiError {
+  constructor(...args) {
+    super(...args);
+    this.name = "NotFoundError";
+  }
+};
+var SchemaNotFoundError = class extends NotFoundError {
+  constructor(...args) {
+    super(...args);
+    this.name = "SchemaNotFoundError";
+  }
+};
+var IncortaServerError = class extends IncortaApiError {
+  constructor(...args) {
+    super(...args);
+    this.name = "IncortaServerError";
+  }
+};
+var TableNotFoundError = class extends IncortaError {
+  constructor(schemaName, tableName, available = []) {
+    const preview = [...available].sort().slice(0, 10).join(", ");
+    const suffix = available.length > 10 ? ", ..." : "";
+    super(
+      `Table or view "${tableName}" not found in schema "${schemaName}".` + (preview ? ` Available: ${preview}${suffix}` : "")
+    );
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.available = available;
+    this.name = "TableNotFoundError";
+  }
+  schemaName;
+  tableName;
+  available;
+};
+var STATUS_MAP = {
+  401: AuthenticationError,
+  403: PermissionDeniedError,
+  404: NotFoundError
+};
+function apiErrorFromResponse(statusCode, body, options = {}) {
+  let detail = "";
+  const payload = options.payload;
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    const candidate = record.message ?? record.error;
+    if (typeof candidate === "string") {
+      detail = candidate;
+    } else if (Array.isArray(record.errorMessages)) {
+      detail = record.errorMessages.map(
+        (item) => item && typeof item === "object" ? item.message : void 0
+      ).filter((message) => typeof message === "string").join("; ");
+    }
+  }
+  if (!detail) {
+    detail = body.trim() || `Request failed with status ${statusCode}`;
+  }
+  let code;
+  const match = CODE_PATTERN.exec(detail);
+  if (match?.[1]) {
+    code = match[1];
+    detail = (match[2] ?? "").trim();
+  }
+  const ErrorClass = STATUS_MAP[statusCode] ?? (statusCode >= 500 ? IncortaServerError : IncortaApiError);
+  return new ErrorClass(statusCode, detail, { code, responseBody: body, url: options.url });
+}
+
+// src/core/config.ts
+function stripTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function resolveConfig(input = {}) {
+  const { auth: provided, timeoutMs, maxRetries, ...authOptions } = input;
+  const timeout = timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new IncortaConfigError("timeoutMs must be a positive number of milliseconds.");
+  }
+  const retries = maxRetries ?? 3;
+  if (!Number.isInteger(retries) || retries < 0) {
+    throw new IncortaConfigError("maxRetries must be an integer >= 0.");
+  }
+  let auth;
+  try {
+    auth = provided ?? createIncortaAuth(authOptions);
+  } catch (error) {
+    throw new IncortaConfigError(
+      `Could not configure OAuth: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const baseUrl = stripTrailingSlash(auth.config.internalIncortaUrl ?? auth.config.incortaUrl);
+  const tenant = auth.config.tenant;
+  return {
+    auth,
+    baseUrl,
+    tenant,
+    apiRoot: `${baseUrl}/api/v2/${tenant}`,
+    timeoutMs: timeout,
+    maxRetries: retries,
+    // The same fetch the auth SDK uses for its own server-to-server calls, so a
+    // proxy agent or test double installed there covers metadata calls too.
+    fetch: auth.config.fetch
+  };
+}
+
+// src/core/enums.ts
+var SCHEMA_TYPES = ["ALL", "PHYSICAL", "BUSINESS"];
+var SORT_ORDERS = ["NAME_ASC", "NAME_DESC"];
+function parseObjectType(raw) {
+  if (!raw) return "UNKNOWN";
+  const normalised = raw.trim().toUpperCase();
+  if (normalised === "TABLE") return "table";
+  if (normalised === "BUSSINESS_VIEW" || normalised === "BUSINESS_VIEW") {
+    return "BUSSINESS_VIEW";
+  }
+  return "UNKNOWN";
+}
+var QUERY_FORMATS = ["json", "csv"];
+var FILTER_OPS = ["=", "!=", ">", ">=", "<", "<=", "BETWEEN", "IN_LIST"];
+var AGGREGATIONS = [
+  "sum",
+  "count",
+  "distinct",
+  "median",
+  "average",
+  "min",
+  "max"
+];
+var NULL_VALUE_AS = ["NULL", "EMPTY"];
+var SORT_DIRECTIONS = ["asc", "desc"];
+var COLUMN_FUNCTIONS = ["key", "dimension", "measure", "attribute", "unknown"];
+function parseColumnFunction(raw) {
+  if (!raw) return "unknown";
+  const normalised = raw.trim().toLowerCase();
+  return COLUMN_FUNCTIONS.includes(normalised) ? normalised : "unknown";
+}
+
+// src/core/http.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var BACKOFF_BASE_MS = 500;
+var USER_AGENT = "incorta-sdk-ts";
+function urlFor(config, ...segments) {
+  const encoded = segments.map((segment) => encodeURIComponent(segment)).join("/");
+  return `${config.apiRoot}/${encoded}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryAfterMs(response) {
+  const header = response.headers.get("retry-after");
+  if (!header) return null;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+}
+function isTimeout(error) {
+  return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+async function postJson(context, url, options = {}) {
+  const { config } = context;
+  const target = options.params ? `${url}?${new URLSearchParams(options.params).toString()}` : url;
+  for (let attempt = 0; ; attempt += 1) {
+    const token = await context.getToken();
+    let response;
+    try {
+      response = await config.fetch(target, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${token}`,
+          accept: "application/json",
+          "content-type": "application/json",
+          "user-agent": USER_AGENT
+        },
+        body: JSON.stringify(options.body ?? {}),
+        signal: AbortSignal.timeout(config.timeoutMs)
+      });
+    } catch (error) {
+      if (isTimeout(error)) {
+        throw new IncortaTimeoutError(
+          `Request to ${target} timed out after ${config.timeoutMs}ms.`
+        );
+      }
+      if (attempt < config.maxRetries) {
+        await sleep(BACKOFF_BASE_MS * 2 ** attempt);
+        continue;
+      }
+      throw new IncortaConnectionError(
+        `Could not reach ${target}: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+    if (RETRY_STATUSES.has(response.status) && attempt < config.maxRetries) {
+      await sleep(retryAfterMs(response) ?? BACKOFF_BASE_MS * 2 ** attempt);
+      continue;
+    }
+    return decode(response, target);
+  }
+}
+async function decode(response, url) {
+  const body = await response.text();
+  let payload;
+  if (body.trim()) {
+    try {
+      payload = JSON.parse(body);
+    } catch {
+      payload = void 0;
+    }
+  }
+  if (!response.ok) {
+    throw apiErrorFromResponse(response.status, body, { url, payload });
+  }
+  if (payload === void 0) {
+    throw new IncortaApiError(
+      response.status,
+      "Expected a JSON response from Incorta but the body was not valid JSON.",
+      { responseBody: body, url }
+    );
+  }
+  return payload;
+}
+
+// src/core/query.ts
+var DEFAULT_QUERY_PAGE_SIZE = 1e3;
+function oneOf(value, allowed, what, normalise = (raw) => raw) {
+  const candidate = normalise(String(value).trim());
+  if (allowed.includes(candidate)) return candidate;
+  throw new IncortaConfigError(
+    `Invalid ${what} "${value}". Expected one of: ${allowed.join(", ")}.`
+  );
+}
+function validateNullValueAs(value) {
+  if (String(value).trim().toUpperCase() === "DASH") {
+    throw new IncortaConfigError(
+      `nullValueAs "DASH" appears in Incorta's API documentation but the server rejects it with HTTP 400. Use NULL or EMPTY.`
+    );
+  }
+  return oneOf(value, NULL_VALUE_AS, "null representation", (raw) => raw.toUpperCase());
+}
+function clean(payload) {
+  const out = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value) && value.length === 0) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function requireFieldOrFormula(field, formula, what) {
+  if (!field && !formula) {
+    throw new IncortaConfigError(`${what} needs either a field or a formula.`);
+  }
+  if (field && formula) {
+    throw new IncortaConfigError(
+      `${what} takes a field or a formula, not both \u2014 Incorta would ignore one silently.`
+    );
+  }
+}
+function toMeasure(value) {
+  return typeof value === "string" ? { field: value } : value;
+}
+function toDimension(value) {
+  return typeof value === "string" ? { field: value } : value;
+}
+function sortToApi(sort) {
+  return clean({
+    field: sort.field,
+    formula: sort.formula,
+    label: sort.label,
+    dir: oneOf(sort.dir ?? "asc", SORT_DIRECTIONS, "sort direction", (raw) => raw.toLowerCase()),
+    measureIndex: sort.measureIndex
+  });
+}
+function filterToApi(filter) {
+  if (filter.type !== "fieldKey" && filter.type !== "formulaKey") {
+    throw new IncortaConfigError(
+      `Invalid filter type "${filter.type}". Expected "fieldKey" or "formulaKey".`
+    );
+  }
+  if (filter.type === "fieldKey" && !filter.fieldKey) {
+    throw new IncortaConfigError("A fieldKey filter needs fieldKey.");
+  }
+  if (filter.type === "formulaKey" && !filter.formulaKey) {
+    throw new IncortaConfigError("A formulaKey filter needs formulaKey.");
+  }
+  const op = filter.op === void 0 ? void 0 : oneOf(filter.op, FILTER_OPS, "filter operator");
+  const values = (filter.values ?? []).map(String);
+  if (op === "BETWEEN" && values.length !== 2) {
+    throw new IncortaConfigError("BETWEEN needs exactly two values.");
+  }
+  const value = clean({
+    values,
+    op,
+    options: filter.caseSensitive === void 0 ? void 0 : { caseSensitive: filter.caseSensitive }
+  });
+  return clean({
+    type: filter.type,
+    label: filter.label,
+    fieldKey: filter.fieldKey,
+    formulaKey: filter.formulaKey,
+    value: Object.keys(value).length > 0 ? value : void 0,
+    prompt: filter.prompt || void 0
+  });
+}
+function aggregateFilterToApi(filter) {
+  requireFieldOrFormula(filter.field, filter.formula, "An aggregate filter");
+  const op = filter.op === void 0 ? void 0 : oneOf(filter.op, FILTER_OPS, "filter operator");
+  if (op === "IN_LIST") {
+    throw new IncortaConfigError("IN_LIST is not accepted by aggregate filters.");
+  }
+  const values = (filter.values ?? []).map(String);
+  if (op === "BETWEEN" && values.length !== 2) {
+    throw new IncortaConfigError("BETWEEN needs exactly two values.");
+  }
+  return clean({
+    field: filter.field,
+    formula: filter.formula,
+    op,
+    values,
+    aggregation: filter.aggregation === void 0 ? void 0 : oneOf(filter.aggregation, AGGREGATIONS, "aggregation", (raw) => raw.toLowerCase())
+  });
+}
+function measureToApi(measure) {
+  requireFieldOrFormula(measure.field, measure.formula, "A measure");
+  return clean({
+    field: measure.field,
+    formula: measure.formula,
+    label: measure.label,
+    aggregation: measure.aggregation === void 0 ? void 0 : oneOf(measure.aggregation, AGGREGATIONS, "aggregation", (raw) => raw.toLowerCase()),
+    scale: measure.scale,
+    sourceField: measure.sourceField,
+    filters: (measure.filters ?? []).map(filterToApi)
+  });
+}
+function dimensionToApi(dimension, asRow) {
+  requireFieldOrFormula(dimension.field, dimension.formula, "A dimension");
+  if (!asRow && (dimension.subTotal || dimension.showEmptyGroups)) {
+    throw new IncortaConfigError("subTotal and showEmptyGroups apply to row dimensions only.");
+  }
+  return clean({
+    field: dimension.field,
+    formula: dimension.formula,
+    label: dimension.label,
+    sorting: (dimension.sorting ?? []).map(sortToApi),
+    datePart: dimension.datePart || void 0,
+    subTotal: asRow ? dimension.subTotal || void 0 : void 0,
+    showEmptyGroups: asRow ? dimension.showEmptyGroups || void 0 : void 0
+  });
+}
+function attachSorts(sorting, dims, payloads) {
+  for (const sort of sorting) {
+    const target = sort.field ?? sort.formula;
+    const index = dims.findIndex(
+      (dim) => target !== void 0 && (dim.field === target || dim.formula === target)
+    );
+    if (index === -1) {
+      const available = dims.map((dim) => dim.field ?? dim.formula ?? "?");
+      throw new IncortaConfigError(
+        `Cannot sort an aggregate query by "${target}": it is not one of its dimensions (${available.join(", ") || "none given"}). Incorta ignores sorting on anything else in an aggregate query and returns HTTP 200, so this is rejected rather than silently dropped.`
+      );
+    }
+    const payload = payloads[index];
+    const existing = payload.sorting ?? [];
+    payload.sorting = [...existing, sortToApi(sort)];
+  }
+}
+function uniqueLabels(labels) {
+  const seen = /* @__PURE__ */ new Map();
+  return labels.map((label) => {
+    const count = seen.get(label) ?? 0;
+    seen.set(label, count + 1);
+    return count === 0 ? label : `${label}_${count + 1}`;
+  });
+}
+function headersOf(raw, kind) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item) => typeof item === "object" && item !== null).map((item) => ({
+    label: String(item.label ?? ""),
+    dataType: String(item.dataType ?? ""),
+    kind,
+    raw: item
+  }));
+}
+function intOf(payload, key) {
+  const value = Number(payload[key]);
+  return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function parseQueryResult(payload) {
+  const columns = [
+    ...headersOf(payload.rowHeaders, "row"),
+    ...headersOf(payload.colHeaders, "column"),
+    ...headersOf(payload.measureHeaders, "measure")
+  ];
+  const rows = (Array.isArray(payload.data) ? payload.data : []).filter((row) => Array.isArray(row)).map((row) => row.map((cell) => cell === null || cell === void 0 ? "" : String(cell)));
+  const headers = columns.map((column) => column.label);
+  const totalRows = intOf(payload, "totalRows");
+  const endRow = intOf(payload, "endRow");
+  const complete = payload.complete === void 0 ? true : Boolean(payload.complete);
+  return {
+    columns,
+    headers,
+    rows,
+    totalRows,
+    startRow: intOf(payload, "startRow"),
+    endRow,
+    complete,
+    hasMore: !complete && endRow < totalRows,
+    isAggregated: Boolean(payload.isAggregated),
+    isSampled: Boolean(payload.isSampled),
+    raw: payload,
+    records() {
+      const keys = uniqueLabels(headers);
+      return rows.map((row) => {
+        const record = {};
+        keys.forEach((key, index) => {
+          record[key] = row[index] ?? "";
+        });
+        return record;
+      });
+    },
+    column(label) {
+      const target = label.toLowerCase();
+      const index = headers.findIndex((header) => header.toLowerCase() === target);
+      if (index === -1) {
+        throw new IncortaConfigError(
+          `No column "${label}" in this result. Available: ${headers.join(", ")}.`
+        );
+      }
+      return rows.map((row) => row[index] ?? "");
+    }
+  };
+}
+function createDataResource(context) {
+  function buildBody(measures, options = {}) {
+    if (!measures || measures.length === 0) {
+      throw new IncortaConfigError(
+        "A query needs at least one measure \u2014 the field or fields to return."
+      );
+    }
+    const pageSize = options.pageSize ?? 0;
+    const startRow = options.startRow ?? 0;
+    if (!Number.isInteger(pageSize) || pageSize < 0) {
+      throw new IncortaConfigError("pageSize must be an integer >= 0 (0 means the server default).");
+    }
+    if (!Number.isInteger(startRow) || startRow < 0) {
+      throw new IncortaConfigError("startRow must be an integer >= 0.");
+    }
+    const format = oneOf(
+      options.format ?? "json",
+      QUERY_FORMATS,
+      "result format",
+      (raw) => raw.toLowerCase()
+    );
+    const aggregate = options.aggregate ?? false;
+    const rowDims = (options.rows ?? []).map(toDimension);
+    const colDims = (options.columns ?? []).map(toDimension);
+    const rowPayloads = rowDims.map((dim) => dimensionToApi(dim, true));
+    const colPayloads = colDims.map((dim) => dimensionToApi(dim, false));
+    const query2 = {
+      // Always explicit. Omitting it means "aggregate", and a non-aggregate
+      // extract then silently returns zero rows.
+      aggregate,
+      format,
+      measures: measures.map((measure) => measureToApi(toMeasure(measure)))
+    };
+    const sorting = options.sorting ?? [];
+    if (aggregate) {
+      attachSorts(sorting, [...rowDims, ...colDims], [...rowPayloads, ...colPayloads]);
+    } else if (sorting.length > 0) {
+      query2.sorting = sorting.map(sortToApi);
+    }
+    if (rowPayloads.length > 0) query2.rows = rowPayloads;
+    if (colPayloads.length > 0) query2.columns = colPayloads;
+    if (options.filters?.length) query2.filters = options.filters.map(filterToApi);
+    if (options.aggregateFilters?.length) {
+      query2.aggregateFilters = options.aggregateFilters.map(aggregateFilterToApi);
+    }
+    if (pageSize) query2.pageSize = pageSize;
+    if (startRow) query2.startRow = startRow;
+    if (options.formatted) query2.formatted = true;
+    if (options.sampled) query2.sampled = true;
+    if (options.nullValueAs !== void 0) {
+      query2.nullValueAs = validateNullValueAs(options.nullValueAs);
+    }
+    Object.assign(query2, options.advanced ?? {});
+    const body = { query: query2 };
+    if (format === "json") body.stringify = false;
+    if (options.asUser !== void 0) {
+      if (!options.asUser.trim()) {
+        throw new IncortaConfigError("asUser must be a non-empty login name.");
+      }
+      body.username = Buffer.from(options.asUser, "utf8").toString("base64");
+    }
+    return body;
+  }
+  function send(body) {
+    return postJson(context, urlFor(context.config, "query"), { body });
+  }
+  async function query(measures, options = {}) {
+    const payload = await send(buildBody(measures, { ...options, format: "json" }));
+    return parseQueryResult(payload ?? {});
+  }
+  return {
+    query,
+    buildBody,
+    raw: send,
+    async *iterRows(measures, options = {}) {
+      const pageSize = options.pageSize ?? DEFAULT_QUERY_PAGE_SIZE;
+      if (!Number.isInteger(pageSize) || pageSize <= 0) {
+        throw new IncortaConfigError("pageSize must be a positive integer.");
+      }
+      let startRow = 0;
+      for (; ; ) {
+        const page = await query(measures, { ...options, pageSize, startRow });
+        yield* page.rows;
+        if (page.rows.length === 0 || !page.hasMore) return;
+        startRow += page.rows.length;
+      }
+    },
+    async csv(measures, options = {}) {
+      const payload = await send(buildBody(measures, { ...options, format: "csv" }));
+      const text = payload && typeof payload === "object" ? payload.data : void 0;
+      if (typeof text !== "string") {
+        throw new IncortaConfigError(
+          "Expected a CSV payload under 'data' but Incorta returned something else."
+        );
+      }
+      return text;
+    }
+  };
+}
+
+// src/core/models.ts
+function str(payload, key, fallback = "") {
+  const value = payload[key];
+  if (value === null || value === void 0) return fallback;
+  return typeof value === "string" ? value : String(value);
+}
+function bool(payload, key) {
+  return Boolean(payload[key]);
+}
+function int(payload, key) {
+  const value = Number(payload[key]);
+  return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function epochMillisToDate(value) {
+  const millis = Number(value);
+  if (!Number.isFinite(millis) || millis <= 0) return null;
+  return new Date(millis);
+}
+function records(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "object" && item !== null);
+}
+function parseTableColumn(payload) {
+  const fn = parseColumnFunction(str(payload, "function") || null);
+  return {
+    kind: "tableColumn",
+    name: str(payload, "name"),
+    label: str(payload, "label"),
+    description: str(payload, "description"),
+    dataType: str(payload, "dataType"),
+    function: fn,
+    formula: str(payload, "formula"),
+    isEncrypted: bool(payload, "isEncrypt"),
+    isKey: fn === "key",
+    raw: payload
+  };
+}
+function parseViewColumn(payload) {
+  return {
+    kind: "viewColumn",
+    name: str(payload, "name"),
+    label: str(payload, "label"),
+    description: str(payload, "description"),
+    dataType: str(payload, "dataType"),
+    function: parseColumnFunction(str(payload, "function") || null),
+    source: str(payload, "source"),
+    isFormula: bool(payload, "isFormula"),
+    raw: payload
+  };
+}
+function qualify(schemaName, name) {
+  return schemaName ? `${schemaName}.${name}` : name;
+}
+function parseTable(payload, schemaName) {
+  const columns = records(payload.columns).map(parseTableColumn);
+  const name = str(payload, "name");
+  return {
+    kind: "table",
+    name,
+    type: parseObjectType(str(payload, "type") || null),
+    owner: str(payload, "owner"),
+    description: str(payload, "description"),
+    schemaName,
+    qualifiedName: qualify(schemaName, name),
+    columns,
+    columnNames: columns.map((column) => column.name),
+    keys: columns.filter((column) => column.isKey),
+    rowsCount: int(payload, "rowsCount"),
+    multiDataSource: bool(payload, "multiDataSource"),
+    hierarchy: bool(payload, "hierarchy"),
+    lastVersion: epochMillisToDate(payload.lastVersionTimestamp),
+    raw: payload
+  };
+}
+function parseView(payload, schemaName) {
+  const columns = records(payload.columns).map(parseViewColumn);
+  const name = str(payload, "name");
+  return {
+    kind: "view",
+    name,
+    type: parseObjectType(str(payload, "type") || null),
+    owner: str(payload, "owner"),
+    description: str(payload, "description"),
+    schemaName,
+    qualifiedName: qualify(schemaName, name),
+    columns,
+    columnNames: columns.map((column) => column.name),
+    baseTable: str(payload, "baseTable"),
+    sources: [...new Set(columns.map((column) => column.source).filter(Boolean))],
+    raw: payload
+  };
+}
+function parseSchemaInfo(payload) {
+  const type = str(payload, "schemaType");
+  return {
+    id: int(payload, "schemaID"),
+    name: str(payload, "schemaName"),
+    description: str(payload, "schemaDescription"),
+    type,
+    owner: str(payload, "owner"),
+    lastModified: epochMillisToDate(payload.lastModified),
+    isEmpty: bool(payload, "isEmpty"),
+    isPhysical: type.toUpperCase() === "PHYSICAL",
+    isBusiness: type.toUpperCase() === "BUSINESS",
+    raw: payload
+  };
+}
+function parseSchema(payload, name) {
+  const total2 = int(payload, "total");
+  const viewsPayload = records(payload.viewsDetails);
+  if (viewsPayload.length > 0) {
+    const views = viewsPayload.map((item) => parseView(item, name));
+    return {
+      kind: "business",
+      name,
+      total: total2,
+      objects: views,
+      objectNames: views.map((view) => view.name),
+      views,
+      raw: payload
+    };
+  }
+  const tables = records(payload.tablesDetails).map((item) => parseTable(item, name));
+  return {
+    kind: "physical",
+    name,
+    total: total2,
+    objects: tables,
+    objectNames: tables.map((table) => table.name),
+    tables,
+    raw: payload
+  };
+}
+function findObject(schema, name) {
+  const target = name.toLowerCase();
+  return schema.objects.find((object) => object.name.toLowerCase() === target);
+}
+function findColumn(object, name) {
+  const target = name.toLowerCase();
+  return object.columns.find((column) => column.name.toLowerCase() === target);
+}
+
+// src/core/schemas.ts
+var DEFAULT_PAGE_SIZE = 100;
+function validateSchemaType(value) {
+  if (value === void 0) return "ALL";
+  const normalised = String(value).trim().toUpperCase();
+  if (SCHEMA_TYPES.includes(normalised)) return normalised;
+  throw new IncortaConfigError(
+    `Invalid schema type "${value}". Expected one of: ${SCHEMA_TYPES.join(", ")}. Note the Incorta API accepts unknown values silently and returns BUSINESS schemas, so this is validated client-side.`
+  );
+}
+function validateSortBy(value) {
+  if (value === void 0) return "NAME_ASC";
+  const normalised = String(value).trim().toUpperCase();
+  if (SORT_ORDERS.includes(normalised)) return normalised;
+  throw new IncortaConfigError(
+    `Invalid sort order "${value}". Expected one of: ${SORT_ORDERS.join(", ")}.`
+  );
+}
+function validateWindow(limit, offset) {
+  if (!Number.isInteger(limit) || limit < 0) {
+    throw new IncortaConfigError("limit must be an integer >= 0 (0 means no limit).");
+  }
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new IncortaConfigError("offset must be an integer >= 0.");
+  }
+}
+function details(payload, key) {
+  if (!payload || typeof payload !== "object") return [];
+  const value = payload[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (item) => typeof item === "object" && item !== null
+  );
+}
+function total(payload, fallback) {
+  if (!payload || typeof payload !== "object") return fallback;
+  const value = Number(payload.total);
+  return Number.isFinite(value) ? Math.trunc(value) : fallback;
+}
+function createSchemasResource(context) {
+  async function listPage(options = {}) {
+    const schemaType = validateSchemaType(options.type);
+    const ordering = validateSortBy(options.sortBy);
+    const limit = options.limit ?? 0;
+    const offset = options.offset ?? 0;
+    validateWindow(limit, offset);
+    const payload = await postJson(context, urlFor(context.config, "schema", "list"), {
+      params: { schemaType },
+      body: { limit, offset, sortBy: ordering }
+    });
+    const items = details(payload, "schemasDetails").map(parseSchemaInfo);
+    const serverTotal = total(payload, items.length);
+    return {
+      items,
+      total: serverTotal,
+      limit,
+      offset,
+      hasMore: limit === 0 ? false : offset + items.length < serverTotal
+    };
+  }
+  async function list(options = {}) {
+    const page = await listPage(options);
+    return [...page.items];
+  }
+  async function get(name) {
+    if (!name || !name.trim()) {
+      throw new IncortaConfigError("Schema name must be a non-empty string.");
+    }
+    let payload;
+    try {
+      payload = await postJson(context, urlFor(context.config, "schema", name, "list"), {
+        body: { limit: 0, offset: 0 }
+      });
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        throw new SchemaNotFoundError(error.statusCode, error.detail, {
+          code: error.code,
+          responseBody: error.responseBody,
+          url: error.url
+        });
+      }
+      throw error;
+    }
+    return parseSchema(payload, name);
+  }
+  return {
+    list,
+    listPage,
+    async *iterAll(options = {}) {
+      const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+      if (!Number.isInteger(pageSize) || pageSize <= 0) {
+        throw new IncortaConfigError("pageSize must be a positive integer.");
+      }
+      let offset = 0;
+      for (; ; ) {
+        const page = await listPage({
+          type: options.type,
+          sortBy: options.sortBy,
+          limit: pageSize,
+          offset
+        });
+        yield* page.items;
+        if (page.items.length === 0 || !page.hasMore) return;
+        offset += page.items.length;
+      }
+    },
+    physical: (options = {}) => list({ ...options, type: "PHYSICAL" }),
+    business: (options = {}) => list({ ...options, type: "BUSINESS" }),
+    get,
+    async exists(name) {
+      try {
+        await get(name);
+        return true;
+      } catch (error) {
+        if (error instanceof SchemaNotFoundError) return false;
+        throw error;
+      }
+    }
+  };
+}
+
+// src/core/tables.ts
+function createTablesResource(schemas) {
+  async function get(schemaName, tableName) {
+    if (!tableName || !tableName.trim()) {
+      throw new IncortaConfigError("Table name must be a non-empty string.");
+    }
+    const schema = await schemas.get(schemaName);
+    const found = findObject(schema, tableName);
+    if (!found) {
+      throw new TableNotFoundError(schemaName, tableName, [...schema.objectNames]);
+    }
+    return found;
+  }
+  return {
+    get,
+    async list(schemaName) {
+      const schema = await schemas.get(schemaName);
+      return [...schema.objects];
+    },
+    async names(schemaName) {
+      const schema = await schemas.get(schemaName);
+      return [...schema.objectNames];
+    },
+    async columns(schemaName, tableName) {
+      const object = await get(schemaName, tableName);
+      return [...object.columns];
+    },
+    async exists(schemaName, tableName) {
+      try {
+        await get(schemaName, tableName);
+        return true;
+      } catch (error) {
+        if (error instanceof TableNotFoundError) return false;
+        throw error;
+      }
+    },
+    async tablesOnly(schemaName) {
+      const schema = await schemas.get(schemaName);
+      return schema.kind === "physical" ? [...schema.tables] : [];
+    },
+    async viewsOnly(schemaName) {
+      const schema = await schemas.get(schemaName);
+      return schema.kind === "business" ? [...schema.views] : [];
+    }
+  };
+}
+
+// src/core/user-client.ts
+function createUserClient(config, options) {
+  const context = { config, getToken: options.getToken };
+  const schemas = createSchemasResource(context);
+  const user = options.user ?? null;
+  return {
+    user,
+    schemas,
+    tables: createTablesResource(schemas),
+    data: createDataResource(context),
+    info: {
+      baseUrl: config.baseUrl,
+      tenant: config.tenant,
+      user: user?.sub,
+      accessTokenExpiresAt: options.accessTokenExpiresAt ?? 0
+    }
+  };
+}
+
+// src/index.ts
+function createIncortaClient(config = {}) {
+  const resolved = resolveConfig(config);
+  function forSession(session) {
+    return createUserClient(resolved, {
+      // Checked at call time, not now: a client built at the top of a request
+      // should not fail for a token that is still valid when it is used.
+      getToken: () => {
+        if (session.accessTokenExpiresAt <= Date.now()) {
+          throw new IncortaSessionExpiredError(session.accessTokenExpiresAt);
+        }
+        return session.accessToken;
+      },
+      user: session.user,
+      accessTokenExpiresAt: session.accessTokenExpiresAt
+    });
+  }
+  return {
+    auth: resolved.auth,
+    forSession,
+    async forRequest(request) {
+      const session = await resolved.auth.getSession(request);
+      if (!session) throw new IncortaAuthRequiredError();
+      return forSession(session);
+    },
+    forAccessToken(accessToken, options = {}) {
+      return createUserClient(resolved, {
+        getToken: () => accessToken,
+        user: options.user
+      });
+    },
+    info: {
+      baseUrl: resolved.baseUrl,
+      tenant: resolved.tenant,
+      timeoutMs: resolved.timeoutMs,
+      maxRetries: resolved.maxRetries
+    }
+  };
+}
+export {
+  AGGREGATIONS,
+  AuthenticationError,
+  COLUMN_FUNCTIONS,
+  DEFAULT_PAGE_SIZE,
+  DEFAULT_QUERY_PAGE_SIZE,
+  FILTER_OPS,
+  IncortaApiError,
+  IncortaAuthRequiredError,
+  IncortaConfigError,
+  IncortaConnectionError,
+  IncortaError,
+  IncortaServerError,
+  IncortaSessionExpiredError,
+  IncortaTimeoutError,
+  NULL_VALUE_AS,
+  NotFoundError,
+  PermissionDeniedError,
+  QUERY_FORMATS,
+  SCHEMA_TYPES,
+  SORT_DIRECTIONS,
+  SORT_ORDERS,
+  SchemaNotFoundError,
+  TableNotFoundError,
+  createIncortaClient,
+  findColumn,
+  findObject,
+  parseColumnFunction,
+  parseObjectType,
+  parseQueryResult
+};
+//# sourceMappingURL=index.js.map