@ominity/api-typescript 0.0.1 → 0.0.2

package/src/models/operations/commerce-cart-items.ts

@@ -0,0 +1,125 @@
+/*
+ * Commerce cart items operations.
+ */
+
+import * as z from "zod/v4";
+import { CartItem, CartItemsListResponse } from "../commerce/cart-item.js";
+
+export type CartItemsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CartItemGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCartItemsRequest = CartItemsListParams & {
+  cartId: string;
+};
+export type ListCartItemsResponse = CartItemsListResponse;
+
+export type GetCartItemRequest = CartItemGetParams & {
+  cartId: string;
+  itemId: string;
+};
+export type GetCartItemResponse = CartItem;
+
+export type CartItemCreateInput = {
+  productId: number;
+  productOfferId?: number | undefined;
+  quantity?: number | undefined;
+};
+export type CartItemUpdateInput = {
+  quantity?: number | undefined;
+};
+
+export type CreateCartItemRequest = {
+  cartId: string;
+  body: CartItemCreateInput;
+};
+export type CreateCartItemResponse = CartItem;
+
+export type UpdateCartItemRequest = {
+  cartId: string;
+  itemId: string;
+  body: CartItemUpdateInput;
+};
+export type UpdateCartItemResponse = CartItem;
+
+export type DeleteCartItemRequest = {
+  cartId: string;
+  itemId: string;
+};
+export type DeleteCartItemResponse = void;
+
+/** @internal */
+export const CartItemsListParams$outboundSchema: z.ZodType<CartItemsListParams> =
+  z.object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();
+
+/** @internal */
+export const CartItemGetParams$outboundSchema: z.ZodType<CartItemGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const ListCartItemsRequest$outboundSchema: z.ZodType<
+  ListCartItemsRequest
+> = z.object({
+  cartId: z.string(),
+  page: z.number().int().optional(),
+  limit: z.number().int().optional(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+  filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+  sort: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const GetCartItemRequest$outboundSchema: z.ZodType<GetCartItemRequest> =
+  z.object({
+    cartId: z.string(),
+    itemId: z.string(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();
+
+/** @internal */
+export const CreateCartItemRequest$outboundSchema: z.ZodType<
+  CreateCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  body: z.object({
+    productId: z.number(),
+    productOfferId: z.number().optional(),
+    quantity: z.number().optional(),
+  }).loose(),
+});
+
+/** @internal */
+export const UpdateCartItemRequest$outboundSchema: z.ZodType<
+  UpdateCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  itemId: z.string(),
+  body: z.object({
+    quantity: z.number().optional(),
+  }).loose(),
+});
+
+/** @internal */
+export const DeleteCartItemRequest$outboundSchema: z.ZodType<
+  DeleteCartItemRequest
+> = z.object({
+  cartId: z.string(),
+  itemId: z.string(),
+});

package/src/models/operations/commerce-carts.ts

@@ -0,0 +1,158 @@
+/*
+ * Commerce carts operations.
+ */
+
+import * as z from "zod/v4";
+import { Cart, CartType, CartsListResponse } from "../commerce/cart.js";
+import { Address, Address$inboundSchema } from "../commerce/address.js";
+
+export type CartsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CartGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCartsRequest = CartsListParams;
+export type ListCartsResponse = CartsListResponse;
+
+export type GetCartRequest = CartGetParams & {
+  id: string;
+};
+
+export type GetCartResponse = Cart;
+
+export type CartItemInput = {
+  id?: string | undefined;
+  productId: number;
+  productOfferId?: number | undefined;
+  quantity?: number | undefined;
+};
+
+export type CartCreateInput = {
+  visitorId?: number | null | undefined;
+  customerId?: number | null | undefined;
+  userId?: number | null | undefined;
+  type?: CartType | undefined;
+  email?: string | null | undefined;
+  companyName?: string | null | undefined;
+  companyVat?: string | null | undefined;
+  taxExempt?: boolean | undefined;
+  country: string;
+  currency?: string | null | undefined;
+  billingAddress?: Address | null | undefined;
+  shippingAddress?: Address | null | undefined;
+  items?: CartItemInput[] | undefined;
+  shippingMethodId?: number | null | undefined;
+  promotionCodes?: string[] | null | undefined;
+};
+
+export type CartUpdateInput = {
+  visitorId?: number | null | undefined;
+  customerId?: number | null | undefined;
+  userId?: number | null | undefined;
+  email?: string | null | undefined;
+  companyName?: string | null | undefined;
+  companyVat?: string | null | undefined;
+  taxExempt?: boolean | undefined;
+  country?: string | undefined;
+  currency?: string | undefined;
+  billingAddress?: Address | null | undefined;
+  shippingAddress?: Address | null | undefined;
+  items?: CartItemInput[] | undefined;
+  shippingMethodId?: number | null | undefined;
+  promotionCodes?: string[] | null | undefined;
+};
+
+export type CreateCartRequest = CartCreateInput;
+export type CreateCartResponse = Cart;
+
+export type UpdateCartRequest = {
+  id: string;
+  body: CartUpdateInput;
+};
+
+export type UpdateCartResponse = Cart;
+
+/** @internal */
+export const CartsListParams$outboundSchema: z.ZodType<CartsListParams> = z
+  .object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const CartGetParams$outboundSchema: z.ZodType<CartGetParams> = z.object({
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const GetCartRequest$outboundSchema: z.ZodType<GetCartRequest> = z.object({
+  id: z.string(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+const CartItemInput$outboundSchema: z.ZodType<CartItemInput> = z.object({
+  id: z.string().optional(),
+  productId: z.number(),
+  productOfferId: z.number().optional(),
+  quantity: z.number().optional(),
+}).loose();
+
+/** @internal */
+const CartType$outboundSchema: z.ZodType<CartType> = z.string().transform(
+  (value) => value as CartType,
+);
+
+export const CreateCartRequest$outboundSchema: z.ZodType<CreateCartRequest> = z
+  .object({
+    visitorId: z.number().nullable().optional(),
+    customerId: z.number().nullable().optional(),
+    userId: z.number().nullable().optional(),
+    type: CartType$outboundSchema.optional(),
+    email: z.string().nullable().optional(),
+    companyName: z.string().nullable().optional(),
+    companyVat: z.string().nullable().optional(),
+    taxExempt: z.boolean().optional(),
+    country: z.string(),
+    currency: z.string().nullable().optional(),
+    billingAddress: Address$inboundSchema.nullable().optional(),
+    shippingAddress: Address$inboundSchema.nullable().optional(),
+    items: z.array(CartItemInput$outboundSchema).optional(),
+    shippingMethodId: z.number().nullable().optional(),
+    promotionCodes: z.array(z.string()).nullable().optional(),
+  })
+  .loose()
+  .transform((v) => v as CreateCartRequest);
+
+/** @internal */
+export const UpdateCartRequest$outboundSchema: z.ZodType<UpdateCartRequest> = z
+  .object({
+    id: z.string(),
+    body: z.object({
+      visitorId: z.number().nullable().optional(),
+      customerId: z.number().nullable().optional(),
+      userId: z.number().nullable().optional(),
+      email: z.string().nullable().optional(),
+      companyName: z.string().nullable().optional(),
+      companyVat: z.string().nullable().optional(),
+      taxExempt: z.boolean().optional(),
+      country: z.string().optional(),
+      currency: z.string().optional(),
+      billingAddress: Address$inboundSchema.nullable().optional(),
+      shippingAddress: Address$inboundSchema.nullable().optional(),
+      items: z.array(CartItemInput$outboundSchema).optional(),
+      shippingMethodId: z.number().nullable().optional(),
+      promotionCodes: z.array(z.string()).nullable().optional(),
+    }).loose(),
+  }).transform((v) => v as UpdateCartRequest);

package/src/models/operations/commerce-categories.ts

@@ -0,0 +1,52 @@
+/*
+ * Commerce categories operations.
+ */
+
+import * as z from "zod/v4";
+import { Category, CategoriesListResponse } from "../commerce/category.js";
+
+export type CategoriesListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type CategoryGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListCategoriesRequest = CategoriesListParams;
+export type ListCategoriesResponse = CategoriesListResponse;
+
+export type GetCategoryRequest = CategoryGetParams & {
+  id: number | string;
+};
+
+export type GetCategoryResponse = Category;
+
+/** @internal */
+export const CategoriesListParams$outboundSchema: z.ZodType<
+  CategoriesListParams
+> = z.object({
+  page: z.number().int().optional(),
+  limit: z.number().int().optional(),
+  include: z.union([z.string(), z.array(z.string())]).optional(),
+  filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+  sort: z.union([z.string(), z.array(z.string())]).optional(),
+}).loose();
+
+/** @internal */
+export const CategoryGetParams$outboundSchema: z.ZodType<CategoryGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const GetCategoryRequest$outboundSchema: z.ZodType<GetCategoryRequest> =
+  z.object({
+    id: z.union([z.string(), z.number()]),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  }).loose();

package/src/models/operations/commerce-products.ts

@@ -0,0 +1,53 @@
+/*
+ * Commerce products operations.
+ */
+
+import * as z from "zod/v4";
+import { Product, ProductsListResponse } from "../commerce/product.js";
+
+export type ProductsListParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+  include?: string | string[] | undefined;
+  filter?: Record<string, unknown> | string | undefined;
+  sort?: string | string[] | undefined;
+};
+
+export type ProductGetParams = {
+  include?: string | string[] | undefined;
+};
+
+export type ListProductsRequest = ProductsListParams;
+export type ListProductsResponse = ProductsListResponse;
+
+export type GetProductRequest = ProductGetParams & {
+  id: number | string;
+};
+
+export type GetProductResponse = Product;
+
+/** @internal */
+export const ProductsListParams$outboundSchema: z.ZodType<ProductsListParams> = z
+  .object({
+    page: z.number().int().optional(),
+    limit: z.number().int().optional(),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([z.string(), z.record(z.string(), z.any())]).optional(),
+    sort: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const ProductGetParams$outboundSchema: z.ZodType<ProductGetParams> = z
+  .object({
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();
+
+/** @internal */
+export const GetProductRequest$outboundSchema: z.ZodType<GetProductRequest> = z
+  .object({
+    id: z.union([z.string(), z.number()]),
+    include: z.union([z.string(), z.array(z.string())]).optional(),
+  })
+  .loose();

package/src/models/operations/index.ts

@@ -1,2 +1,4 @@
-// Operation models will be defined as the SDK endpoints are implemented.
-export {};
+export * from "./commerce-products.js";
+export * from "./commerce-categories.js";
+export * from "./commerce-carts.js";
+export * from "./commerce-cart-items.js";

package/src/models/pagination.ts

@@ -0,0 +1,146 @@
+/*
+ * Pagination helpers.
+ */
+
+import { HalLinks } from "./hal.js";
+
+export const DEFAULT_PAGE = 1;
+export const DEFAULT_LIMIT = 20;
+
+export type PaginationParams = {
+  page?: number | undefined;
+  limit?: number | undefined;
+};
+
+export type Paginated<T> = {
+  items: T[];
+  count: number;
+  page: number;
+  limit: number;
+  totalPages: number;
+  hasNext: boolean;
+  hasPrevious: boolean;
+  links?: HalLinks;
+};
+
+export function buildPaginated<T>(
+  items: T[],
+  count: number,
+  links?: HalLinks,
+): Paginated<T> {
+  const { page, limit } = parsePaginationFromLinks(links);
+  const resolvedPage = page ?? DEFAULT_PAGE;
+  const resolvedLimit = limit ?? DEFAULT_LIMIT;
+  const totalPages = Math.ceil(count / Math.max(resolvedLimit, 1));
+
+  const nextLink = links?.["next"];
+  const hasNext = typeof nextLink !== "undefined"
+    ? nextLink !== null
+    : resolvedPage < totalPages;
+
+  const previousLink = links?.["previous"];
+  const hasPrevious = typeof previousLink !== "undefined"
+    ? previousLink !== null
+    : resolvedPage > DEFAULT_PAGE;
+
+  const base: Paginated<T> = {
+    items,
+    count,
+    page: resolvedPage,
+    limit: resolvedLimit,
+    totalPages,
+    hasNext,
+    hasPrevious,
+  };
+
+  if (links) {
+    return { ...base, links };
+  }
+
+  return base;
+}
+
+export function applyPaginationParams<T>(
+  response: Paginated<T>,
+  params?: PaginationParams,
+): Paginated<T> {
+  if (!params?.page && !params?.limit) {
+    return response;
+  }
+
+  const page = params?.page ?? response.page;
+  const limit = params?.limit ?? response.limit;
+  const totalPages = Math.ceil(response.count / Math.max(limit, 1));
+  const hasPrevious = page > DEFAULT_PAGE;
+  const hasNext = page < totalPages;
+
+  return {
+    ...response,
+    page,
+    limit,
+    totalPages,
+    hasNext,
+    hasPrevious,
+  };
+}
+
+function parsePaginationFromLinks(links?: HalLinks): {
+  page?: number;
+  limit?: number;
+} {
+  const candidates = [
+    getLinkHref(links, "self"),
+    getLinkHref(links, "first"),
+    getLinkHref(links, "next"),
+    getLinkHref(links, "last"),
+  ];
+
+  for (const href of candidates) {
+    if (!href) continue;
+    const parsed = parsePageLimitFromHref(href);
+    if (parsed.page || parsed.limit) {
+      return parsed;
+    }
+  }
+
+  return {};
+}
+
+function parsePageLimitFromHref(href: string): {
+  page?: number;
+  limit?: number;
+} {
+  const queryIndex = href.indexOf("?");
+  if (queryIndex === -1) {
+    return {};
+  }
+
+  const query = href.slice(queryIndex + 1).split("#")[0];
+  const searchParams = new URLSearchParams(query);
+  const pageRaw = searchParams.get("page");
+  const limitRaw = searchParams.get("limit");
+
+  const page = pageRaw ? Number(pageRaw) : undefined;
+  const limit = limitRaw ? Number(limitRaw) : undefined;
+
+  const out: { page?: number; limit?: number } = {};
+  if (Number.isFinite(page)) {
+    out.page = page as number;
+  }
+  if (Number.isFinite(limit)) {
+    out.limit = limit as number;
+  }
+
+  return out;
+}
+
+function getLinkHref(
+  links: HalLinks | undefined,
+  rel: string,
+): string | undefined {
+  if (!links) return;
+  const link = links[rel];
+  if (!link || typeof link !== "object") return;
+  if (!("href" in link)) return;
+  return typeof link.href === "string" ? link.href : undefined;
+}

package/src/sdk/commerce/cart-items.ts

@@ -0,0 +1,113 @@
+/*
+ * SDK module: Commerce Cart Items
+ */
+
+import { cartItemsCreate } from "../../funcs/commerce/cartItemsCreate.js";
+import { cartItemsDelete } from "../../funcs/commerce/cartItemsDelete.js";
+import { cartItemsGet } from "../../funcs/commerce/cartItemsGet.js";
+import { cartItemsList } from "../../funcs/commerce/cartItemsList.js";
+import { cartItemsUpdate } from "../../funcs/commerce/cartItemsUpdate.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export type CartItemsListParams = operations.CartItemsListParams;
+export type CartItemGetParams = operations.CartItemGetParams;
+export type CartItemCreateInput = operations.CartItemCreateInput;
+export type CartItemUpdateInput = operations.CartItemUpdateInput;
+
+export class CartItems extends ClientSDK {
+  /**
+   * List cart items
+   */
+  async list(
+    cartId: string,
+    params?: CartItemsListParams,
+    options?: RequestOptions,
+  ): Promise<operations.ListCartItemsResponse> {
+    return unwrapAsync(cartItemsList(
+      this,
+      {
+        cartId,
+        ...(params ?? {}),
+      },
+      options,
+    ));
+  }
+
+  /**
+   * Get a cart item by ID
+   */
+  async get(
+    cartId: string,
+    itemId: string,
+    params?: CartItemGetParams,
+    options?: RequestOptions,
+  ): Promise<operations.GetCartItemResponse> {
+    return unwrapAsync(cartItemsGet(
+      this,
+      {
+        cartId,
+        itemId,
+        ...(params ?? {}),
+      },
+      options,
+    ));
+  }
+
+  /**
+   * Create a cart item
+   */
+  async create(
+    cartId: string,
+    body: CartItemCreateInput,
+    options?: RequestOptions,
+  ): Promise<operations.CreateCartItemResponse> {
+    return unwrapAsync(cartItemsCreate(
+      this,
+      {
+        cartId,
+        body,
+      },
+      options,
+    ));
+  }
+
+  /**
+   * Update a cart item
+   */
+  async update(
+    cartId: string,
+    itemId: string,
+    body: CartItemUpdateInput,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateCartItemResponse> {
+    return unwrapAsync(cartItemsUpdate(
+      this,
+      {
+        cartId,
+        itemId,
+        body,
+      },
+      options,
+    ));
+  }
+
+  /**
+   * Delete a cart item
+   */
+  async delete(
+    cartId: string,
+    itemId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(cartItemsDelete(
+      this,
+      {
+        cartId,
+        itemId,
+      },
+      options,
+    ));
+  }
+}