@ominity/api-typescript 0.0.1 → 0.0.3

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,
+    ));
+  }
+}

package/src/sdk/commerce/carts.ts

@@ -0,0 +1,81 @@
+/*
+ * SDK module: Commerce Carts
+ */
+
+import { cartsCreate } from "../../funcs/commerce/cartsCreate.js";
+import { cartsGet } from "../../funcs/commerce/cartsGet.js";
+import { cartsList } from "../../funcs/commerce/cartsList.js";
+import { cartsUpdate } from "../../funcs/commerce/cartsUpdate.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export type CartsListParams = operations.CartsListParams;
+export type CartGetParams = operations.CartGetParams;
+export type CartCreateInput = operations.CartCreateInput;
+export type CartUpdateInput = operations.CartUpdateInput;
+
+export class Carts extends ClientSDK {
+  /**
+   * List carts
+   */
+  async list(
+    params?: CartsListParams,
+    options?: RequestOptions,
+  ): Promise<operations.ListCartsResponse> {
+    return unwrapAsync(cartsList(
+      this,
+      params,
+      options,
+    ));
+  }
+
+  /**
+   * Get a cart by ID
+   */
+  async get(
+    id: string,
+    params?: CartGetParams,
+    options?: RequestOptions,
+  ): Promise<operations.GetCartResponse> {
+    const request: operations.GetCartRequest = {
+      id,
+      ...(params ?? {}),
+    };
+
+    return unwrapAsync(cartsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a cart
+   */
+  async create(
+    body: CartCreateInput,
+    options?: RequestOptions,
+  ): Promise<operations.CreateCartResponse> {
+    return unwrapAsync(cartsCreate(
+      this,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Update a cart
+   */
+  async update(
+    id: string,
+    body: CartUpdateInput,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateCartResponse> {
+    return unwrapAsync(cartsUpdate(
+      this,
+      { id, body },
+      options,
+    ));
+  }
+}

package/src/sdk/commerce/categories.ts

@@ -0,0 +1,48 @@
+/*
+ * SDK module: Commerce Categories
+ */
+
+import { categoriesGet } from "../../funcs/commerce/categoriesGet.js";
+import { categoriesList } from "../../funcs/commerce/categoriesList.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export type CategoriesListParams = operations.CategoriesListParams;
+export type CategoryGetParams = operations.CategoryGetParams;
+
+export class Categories extends ClientSDK {
+  /**
+   * List categories
+   */
+  async list(
+    params?: CategoriesListParams,
+    options?: RequestOptions,
+  ): Promise<operations.ListCategoriesResponse> {
+    return unwrapAsync(categoriesList(
+      this,
+      params,
+      options,
+    ));
+  }
+
+  /**
+   * Get a category by ID
+   */
+  async get(
+    id: number | string,
+    params?: CategoryGetParams,
+    options?: RequestOptions,
+  ): Promise<operations.GetCategoryResponse> {
+    const request: operations.GetCategoryRequest = {
+      id,
+      ...(params ?? {}),
+    };
+
+    return unwrapAsync(categoriesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/commerce/index.ts

@@ -3,10 +3,29 @@
  */
 
 import { ClientSDK } from "../../lib/sdks.js";
+import { CartItems } from "./cart-items.js";
+import { Carts } from "./carts.js";
+import { Categories } from "./categories.js";
 import { Products } from "./products.js";
 
 export class Commerce extends ClientSDK {
+  private _cartItems?: CartItems;
+  private _carts?: Carts;
+  private _categories?: Categories;
   private _products?: Products;
+
+  get cartItems(): CartItems {
+    return (this._cartItems ??= new CartItems(this._options));
+  }
+
+  get carts(): Carts {
+    return (this._carts ??= new Carts(this._options));
+  }
+
+  get categories(): Categories {
+    return (this._categories ??= new Categories(this._options));
+  }
+
   get products(): Products {
     return (this._products ??= new Products(this._options));
   }

package/src/sdk/commerce/products.ts

@@ -2,6 +2,47 @@
  * SDK module: Commerce Products
  */
 
-import { ClientSDK } from "../../lib/sdks.js";
+import { productsGet } from "../../funcs/commerce/productsGet.js";
+import { productsList } from "../../funcs/commerce/productsList.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
 
-export class Products extends ClientSDK {}
+export type ProductsListParams = operations.ProductsListParams;
+export type ProductGetParams = operations.ProductGetParams;
+
+export class Products extends ClientSDK {
+  /**
+   * List products
+   */
+  async list(
+    params?: ProductsListParams,
+    options?: RequestOptions,
+  ): Promise<operations.ListProductsResponse> {
+    return unwrapAsync(productsList(
+      this,
+      params,
+      options,
+    ));
+  }
+
+  /**
+   * Get a product by ID
+   */
+  async get(
+    id: number | string,
+    params?: ProductGetParams,
+    options?: RequestOptions,
+  ): Promise<operations.GetProductResponse> {
+    const request: operations.GetProductRequest = {
+      id,
+      ...(params ?? {}),
+    };
+
+    return unwrapAsync(productsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/modules.ts

@@ -0,0 +1,16 @@
+export interface OminityModules {}
+
+export type OminityModuleDefinition<Client, Name extends string, Mod> = {
+  name: Name;
+  init(client: Client): Mod;
+};
+
+export type OminityModuleFactory<Client, Name extends string, Mod> = () => OminityModuleDefinition<
+  Client,
+  Name,
+  Mod
+>;
+
+export type OminityModuleInput<Client> =
+  | OminityModuleDefinition<Client, string, unknown>
+  | OminityModuleFactory<Client, string, unknown>;

package/src/sdk/sdk.ts

@@ -4,8 +4,37 @@ import { Cms } from "./cms/index.js";
 import { Commerce } from "./commerce/index.js";
 import { Http } from "./http.js";
 import { Settings } from "./settings/index.js";
+import type { SDKOptions } from "../lib/config.js";
+import type {
+  OminityModuleInput,
+  OminityModules,
+} from "./modules.js";
+
+export type OminityOptions = SDKOptions & {
+  modules?: Array<OminityModuleInput<Ominity>> | undefined;
+};
 
 export class Ominity extends ClientSDK {
+  public readonly modules: OminityModules = {} as OminityModules;
+
+  constructor(options: OminityOptions = {}) {
+    const { modules, ...sdkOptions } = options;
+    super(sdkOptions);
+
+    if (modules) {
+      for (const mod of modules) {
+        this.use(mod);
+      }
+    }
+  }
+
+  use(mod: OminityModuleInput<Ominity>): this {
+    const moduleDef = typeof mod === "function" ? mod() : mod;
+    (this.modules as Record<string, unknown>)[moduleDef.name] = moduleDef
+      .init(this);
+    return this;
+  }
+
   private _commerce?: Commerce;
   get commerce(): Commerce {
     return (this._commerce ??= new Commerce(this._options));