import { Refine } from "@refinedev/core";
import { createCratestackDataProvider } from "@cratestack/refine";
import { ExampleApiClientClient } from "@example/api-client";
import { cratestackRefineResources } from "@example/api-client/refine";

const client = new ExampleApiClientClient("https://api.example.com", {
  basePath: "/api",
  headers: async () => ({ authorization: `Bearer ${await getToken()}` }),
});

const dataProvider = createCratestackDataProvider(cratestackRefineResources(client));

export const App = () => (
  <Refine dataProvider={dataProvider} resources={[{ name: "widgets", list: "/widgets" }]} />
);

import { createCratestackRpcDataProvider } from "@cratestack/refine";
import { ExampleApiClientClient } from "@example/api-client";
import { cratestackRefineResources } from "@example/api-client/refine";

const client = new ExampleApiClientClient("https://api.example.com", { basePath: "/api" });
const dataProvider = createCratestackRpcDataProvider(cratestackRefineResources(client));

import { createLoggerLink } from "@cratestack/link-logger";
import { createBatchLink } from "@cratestack/link-batch";

const client = new ExampleApiClientClient("https://api.example.com", {
  basePath: "/api",
  // Order matters: the logger wraps the batch link, so you see one line
  // per aggregate HTTP request. Swap them to log each individual call
  // before it is queued.
  links: [createLoggerLink(), createBatchLink({ windowMs: 10 })],
});

const dataProvider = createCratestackRpcDataProvider(cratestackRefineResources(client));

import axios from "axios";
import { createAxiosRuntime } from "@cratestack/runtime-axios";
import { createBatchLink } from "@cratestack/link-batch";

const api = axios.create({ timeout: 10_000 });
api.interceptors.response.use(undefined, refreshAuthOn401);

// Module scope, NOT inside a component. `createBatchLink` includes the
// fetch function's *identity* in its partition key, so constructing a new
// runtime per render gives every call its own partition and batching
// silently stops happening — no error, just no batching.
const transport = createAxiosRuntime({ instance: api });

const client = new ExampleApiClientClient("https://api.example.com", {
  basePath: "/api",
  fetch: transport,
  links: [createBatchLink()],
});

const dataProvider = createCratestackRpcDataProvider(cratestackRefineResources(client));

cargo run -p cratestack-cli -- generate-typescript \
  --schema schema.cstack \
  --out packages/api-client \
  --package-name @example/api-client \
  --base-path /api

model Widget {
  id Int @id
  name String
  weight Int?

  @@allow("read", auth() != null)
  @@allow("create", auth() != null)
  @@allow("update", auth() != null)
  @@allow("delete", auth() != null)
}

model Ledger {
  id Int @id
  label String
  balance Int
  version Int @version

  @@paged
  @@allow("read", auth() != null)
  @@allow("update", auth() != null)
  @@allow("delete", auth() != null)
}

import type { CratestackFetchQuery, CratestackRequestConfig, Page } from "@example/api-client";
import type {
  DataProvider,
  GetListParams, GetListResponse,
  GetOneParams, GetOneResponse,
  GetManyParams, GetManyResponse,
  CreateParams, CreateResponse,
  UpdateParams, UpdateResponse,
  DeleteOneParams, DeleteOneResponse,
  CustomParams, CustomResponse,
  CrudFilters, CrudSorting, HttpError,
} from "@refinedev/core";

interface ModelApi<TModel, TCreateInput, TUpdateInput> {
  list(options?: { query?: CratestackFetchQuery; headers?: HeadersInit }): Promise<TModel[] | Page<TModel>>;
  get(id: any, options?: { query?: CratestackFetchQuery; headers?: HeadersInit }): Promise<TModel>;
  create?(input: TCreateInput, options?: CratestackRequestConfig): Promise<TModel>;
  update(id: any, input: TUpdateInput, options?: CratestackRequestConfig): Promise<TModel>;
  delete(id: any, options?: CratestackRequestConfig): Promise<void>;
}

interface ResourceConfig<TModel = any, TCreateInput = any, TUpdateInput = any> {
  api: ModelApi<TModel, TCreateInput, TUpdateInput>;
  /** The schema's `@id` field name — refine assumes `id`; cratestack doesn't. */
  primaryKey: string;
  /** Mirrors whether the model declares `@@paged`. */
  paged: boolean;
  /** Mirrors whether the model declares `@version`, and which field it's on. */
  versionField?: string;
}

cratestack generate-typescript \
  --schema schema.cstack \
  --out packages/api-client \
  --refine

import { ExampleApiClientClient } from "@example/api-client";
import { cratestackRefineResources } from "@example/api-client/refine";

const client = new ExampleApiClientClient("https://api.example.com", {
  basePath: "/api",
  headers: async () => ({ authorization: `Bearer ${await getToken()}` }),
});

const resources = cratestackRefineResources(client);

const resources: Record<string, ResourceConfig> = {
  widgets: { api: client.widgets, primaryKey: "id", paged: false },
  ledgers: { api: client.ledgers, primaryKey: "id", paged: true, versionField: "version" },
};

limit  = pageSize
offset = (currentPage - 1) * pageSize
total  = page.totalCount   // refine's GetListResponse.total

async function getList({ resource, pagination, sorters, filters }: GetListParams): Promise<GetListResponse> {
  const config = resources[resource];
  if (!config) throw new Error(`no cratestack resource configured for "${resource}"`);

  const usePaging = config.paged && pagination?.mode !== "off";
  const currentPage = pagination?.currentPage ?? 1; // v4: pagination?.current
  const pageSize = pagination?.pageSize ?? 10;

  const query: CratestackFetchQuery = {
    sort: toSortQuery(sorters),
    filters: toQueryFilters(filters),
    ...(usePaging ? { limit: pageSize, offset: (currentPage - 1) * pageSize } : {}),
  };

  const result = await config.api.list({ query });

  if (config.paged) {
    const page = result as Page<any>;
    return {
      data: page.items.map((item) => withRefineId(item, config.primaryKey)),
      total: page.totalCount ?? page.items.length,
    };
  }

  const items = result as any[];
  return { data: items.map((item) => withRefineId(item, config.primaryKey)), total: items.length };
}

const SUPPORTED_OPERATOR_SUFFIX: Record<string, string | null> = {
  eq: null,
  ne: "ne",
  in: "in",
  lt: "lt",
  lte: "lte",
  gt: "gt",
  gte: "gte",
  contains: "contains",
  startswith: "startsWith",
  null: "isNull",
  nnull: "isNull",
};

function toQueryFilters(filters: CrudFilters = []): Record<string, string> {
  const output: Record<string, string> = {};
  for (const filter of filters) {
    if (!("field" in filter)) {
      throw new Error(
        `refine "${filter.operator}" filter groups have no cratestack equivalent — ` +
          `this dataProvider only supports a flat AND of per-field predicates`,
      );
    }
    if (!(filter.operator in SUPPORTED_OPERATOR_SUFFIX)) {
      throw new Error(
        `refine operator "${filter.operator}" on "${filter.field}" has no cratestack equivalent ` +
          `(supported: ${Object.keys(SUPPORTED_OPERATOR_SUFFIX).join(", ")}) — ` +
          `failing loudly instead of silently returning unfiltered data`,
      );
    }
    const suffix = SUPPORTED_OPERATOR_SUFFIX[filter.operator];
    const key = suffix ? `${filter.field}__${suffix}` : filter.field;
    output[key] = toFilterValue(filter.operator, filter.value);
  }
  return output;
}

function toFilterValue(operator: string, value: unknown): string {
  if (operator === "null") return "true";
  if (operator === "nnull") return "false";
  if (Array.isArray(value)) return value.map(String).join(",");
  if (value instanceof Date) return value.toISOString();
  return String(value);
}

function toSortQuery(sorters: CrudSorting = []): string[] | undefined {
  if (sorters.length === 0) return undefined;
  return sorters.map((s) => (s.order === "desc" ? `-${s.field}` : s.field));
}

const versionCache = new Map<string, number>();
const versionKey = (resource: string, id: unknown) => `${resource}:${id}`;

function rememberVersion(resource: string, id: unknown, record: Record<string, any>, config: ResourceConfig) {
  if (!config.versionField) return;
  const version = record[config.versionField];
  if (typeof version === "number") versionCache.set(versionKey(resource, id), version);
}

function ifMatchHeaders(resource: string, id: unknown, config: ResourceConfig, override?: number): HeadersInit {
  if (!config.versionField) return {};
  const version = override ?? versionCache.get(versionKey(resource, id));
  if (version === undefined) {
    throw new Error(
      `no known version for ${resource}/${id} — call getOne (or getList) before update/delete on a ` +
        `@version model, or pass meta: { ifMatch: <version> } explicitly`,
    );
  }
  return { "If-Match": `"${version}"` };
}

async function update({ resource, id, variables, meta }: UpdateParams): Promise<UpdateResponse> {
  const config = resources[resource];
  const headers = ifMatchHeaders(resource, id, config, meta?.ifMatch as number | undefined);
  try {
    const record = await config.api.update(id, variables, { headers });
    rememberVersion(resource, id, record, config);
    return { data: withRefineId(record, config.primaryKey) };
  } catch (error) {
    throw toRefineError(error);
  }
}

async function deleteOne({ resource, id, meta }: DeleteOneParams): Promise<DeleteOneResponse> {
  const config = resources[resource];
  const headers = ifMatchHeaders(resource, id, config, meta?.ifMatch as number | undefined);
  try {
    await config.api.delete(id, { headers });
    return { data: { id } };
  } catch (error) {
    throw toRefineError(error);
  } finally {
    versionCache.delete(versionKey(resource, id));
  }
}

function toRefineError(error: unknown): HttpError {
  if (error instanceof CratestackHttpError) {
    if (error.status === 412) {
      return {
        message: "This record changed since it was loaded. Reload it and try again.",
        statusCode: 412,
      };
    }
    const payload = error.payload as { message?: string } | undefined;
    return { message: payload?.message ?? error.message, statusCode: error.status };
  }
  return { message: error instanceof Error ? error.message : "Unknown error", statusCode: 500 };
}

async function getOne({ resource, id }: GetOneParams): Promise<GetOneResponse> {
  const config = resources[resource];
  const record = await config.api.get(id);
  rememberVersion(resource, id, record, config);
  return { data: withRefineId(record, config.primaryKey) };
}

async function getMany({ resource, ids }: GetManyParams): Promise<GetManyResponse> {
  const config = resources[resource];
  const query: CratestackFetchQuery = {
    filters: { [`${config.primaryKey}__in`]: ids.map(String).join(",") },
  };
  const result = await config.api.list({ query });
  const items = config.paged ? (result as Page<any>).items : (result as any[]);
  items.forEach((item) => rememberVersion(resource, item[config.primaryKey], item, config));
  return { data: items.map((item) => withRefineId(item, config.primaryKey)) };
}

async function create({ resource, variables }: CreateParams): Promise<CreateResponse> {
  const config = resources[resource];
  if (!config.api.create) {
    throw new Error(
      `"${resource}" has no generated create route — its model declares no ` +
        `@@allow("create", ...) policy`,
    );
  }
  const record = await config.api.create(variables);
  rememberVersion(resource, record[config.primaryKey], record, config);
  return { data: withRefineId(record, config.primaryKey) };
}

async function custom({ payload, meta }: CustomParams): Promise<CustomResponse> {
  const procedureName = meta?.procedure as string | undefined;
  const procedureFn = procedureName ? (client.procedures as Record<string, unknown>)[procedureName] : undefined;
  if (typeof procedureFn !== "function") {
    throw new Error(`custom() needs meta: { procedure: "<name>" } naming a generated procedures.* method`);
  }
  const data = await (procedureFn as (args: unknown) => Promise<unknown>)(payload ?? {});
  return { data };
}

await dataProvider.custom({
  url: "",
  method: "post",
  meta: { procedure: "publishPost" },
  payload: { args: { postId: 1 } },
});

import type { DataProvider } from "@refinedev/core";
import {
  ExampleApiClientClient,
  CratestackHttpError,
  type CratestackFetchQuery,
  type Page,
} from "@example/api-client";

const client = new ExampleApiClientClient("https://api.example.com", { basePath: "/api" });

const resources: Record<string, ResourceConfig> = {
  widgets: { api: client.widgets, primaryKey: "id", paged: false },
  ledgers: { api: client.ledgers, primaryKey: "id", paged: true, versionField: "version" },
};

export const cratestackDataProvider: DataProvider = {
  getApiUrl: () => `${client.runtime.origin}${client.runtime.basePath === "/" ? "" : client.runtime.basePath}`,
  getList,
  getOne,
  getMany,
  create,
  update,
  deleteOne,
  custom,
};