@ominity/api-typescript 0.0.1 → 0.0.3

package/src/funcs/commerce/productsList.ts

@@ -0,0 +1,187 @@
+/*
+ * List products.
+ */
+
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import {
+  encodeDeepObjectQuery,
+  encodeFormQuery,
+  queryJoin,
+} from "../../lib/encodings.js";
+import * as M from "../../lib/matchers.js";
+import { safeParse } from "../../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../../lib/security.js";
+import * as errors from "../../models/errors/index.js";
+import { ResponseValidationError } from "../../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../../models/errors/sdk-validation-error.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../../models/errors/http-client-errors.js";
+import * as operations from "../../models/operations/index.js";
+import { ProductsListResponse$inboundSchema } from "../../models/commerce/product.js";
+import { applyPaginationParams } from "../../models/pagination.js";
+import { APICall, APIPromise } from "../../types/async.js";
+import { OK, Result } from "../../types/fp.js";
+
+export function productsList(
+  client: ClientSDK,
+  request?: operations.ProductsListParams | undefined,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.ListProductsResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: ClientSDK,
+  request?: operations.ProductsListParams | undefined,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.ListProductsResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      operations.ProductsListParams$outboundSchema.optional().parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = "/commerce/products";
+
+  const baseQuery = encodeFormQuery({
+    page: payload?.page,
+    limit: payload?.limit,
+    include: payload?.include,
+    sort: payload?.sort,
+  });
+
+  let filterQuery: string | undefined;
+  if (typeof payload?.filter === "string") {
+    filterQuery = encodeFormQuery({ filter: payload.filter });
+  } else if (
+    payload?.filter != null
+    && typeof payload.filter === "object"
+    && !Array.isArray(payload.filter)
+  ) {
+    filterQuery = encodeDeepObjectQuery({ filter: payload.filter });
+  }
+
+  const query = queryJoin(baseQuery, filterQuery);
+
+  const headers = new Headers();
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "commerce.products.list",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "5XX"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.ListProductsResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, ProductsListResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("4XX"),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  const finalValue = applyPaginationParams(result.value, payload);
+
+  return [OK(finalValue), { status: "complete", request: req, response }];
+}

package/src/funcs/index.ts

@@ -0,0 +1,17 @@
+/*
+ * Standalone SDK functions.
+ */
+
+export * from "./commerce/productsGet.js";
+export * from "./commerce/productsList.js";
+export * from "./commerce/categoriesGet.js";
+export * from "./commerce/categoriesList.js";
+export * from "./commerce/cartsList.js";
+export * from "./commerce/cartsGet.js";
+export * from "./commerce/cartsCreate.js";
+export * from "./commerce/cartsUpdate.js";
+export * from "./commerce/cartItemsList.js";
+export * from "./commerce/cartItemsGet.js";
+export * from "./commerce/cartItemsCreate.js";
+export * from "./commerce/cartItemsUpdate.js";
+export * from "./commerce/cartItemsDelete.js";

package/src/hooks/ominity-hooks.ts

@@ -28,6 +28,10 @@ export class OminityHooks implements BeforeCreateRequestHook {
     headers: Headers,
     hookContext: HookContext,
   ): Headers {
+    if (!headers.has("accept")) {
+      headers.set("Accept", "application/hal+json");
+    }
+
     const language = hookContext.options.language;
     if (language && !headers.has("accept-language")) {
       headers.set("Accept-Language", language);

package/src/index.ts

@@ -3,4 +3,7 @@ export * from "./lib/config.js";
 export * as files from "./lib/files.js";
 export { HTTPClient } from "./lib/http.js";
 export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
+export * from "./core.js";
+export * from "./funcs/index.js";
+export * from "./sdk/modules.js";
 export * from "./sdk/sdk.js";

package/src/lib/config.ts

@@ -75,10 +75,12 @@ function applyApiVersion(url: URL, apiVersion: string | undefined): URL {
   return url;
 }
 
+export const SDK_VERSION = "0.0.3";
+
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "manual",
-  sdkVersion: "0.0.1",
+  sdkVersion: SDK_VERSION,
   genVersion: "manual",
-  userAgent: "ominity-sdk/typescript 0.0.1",
+  userAgent: `ominity-sdk/typescript ${SDK_VERSION}`,
 } as const;

package/src/models/commerce/address.ts

@@ -0,0 +1,30 @@
+/*
+ * Address model.
+ */
+
+import * as z from "zod/v4";
+
+export type Address = {
+  firstName?: string | null | undefined;
+  lastName?: string | null | undefined;
+  street?: string | null | undefined;
+  number?: string | null | undefined;
+  additional?: string | null | undefined;
+  postalCode?: string | null | undefined;
+  city?: string | null | undefined;
+  region?: string | null | undefined;
+  country?: string | null | undefined;
+};
+
+/** @internal */
+export const Address$inboundSchema: z.ZodType<Address> = z.object({
+  firstName: z.string().nullable().optional(),
+  lastName: z.string().nullable().optional(),
+  street: z.string().nullable().optional(),
+  number: z.string().nullable().optional(),
+  additional: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  city: z.string().nullable().optional(),
+  region: z.string().nullable().optional(),
+  country: z.string().nullable().optional(),
+});

package/src/models/commerce/cart-item.ts

@@ -0,0 +1,83 @@
+/*
+ * Cart item model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Product, Product$inboundSchema } from "./product.js";
+import { ProductOffer, ProductOffer$inboundSchema } from "./product-offer.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+
+export type CartItem = {
+  resource: string;
+  id: string;
+  cartId: string;
+  productId: number;
+  productOfferId: number;
+  quantity: number;
+  unitAmount: CurrencyAmount;
+  discountAmount: CurrencyAmount;
+  taxAmount: CurrencyAmount;
+  totalAmount: CurrencyAmount;
+  isShippingRequired: boolean;
+  updatedAt: string;
+  createdAt: string;
+  product?: Product;
+  offer?: ProductOffer;
+  links?: HalLinks;
+};
+
+export type CartItemsListResponse = Paginated<CartItem>;
+
+/** @internal */
+export const CartItem$inboundSchema: z.ZodType<CartItem> = z.object({
+  resource: z.string(),
+  id: z.string(),
+  cartId: z.string(),
+  productId: z.number(),
+  productOfferId: z.number(),
+  quantity: z.number(),
+  unitAmount: CurrencyAmount$inboundSchema,
+  discountAmount: CurrencyAmount$inboundSchema,
+  taxAmount: CurrencyAmount$inboundSchema,
+  totalAmount: CurrencyAmount$inboundSchema,
+  isShippingRequired: z.boolean(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    product: Product$inboundSchema.optional(),
+    offer: ProductOffer$inboundSchema.optional(),
+  }).loose().optional(),
+}).transform((v) => {
+  const { _embedded } = v;
+  const remapped = remap$(v, { _links: "links", _embedded: null });
+
+  if (_embedded?.product !== undefined) {
+    (remapped as CartItem).product = _embedded.product;
+  }
+  if (_embedded?.offer !== undefined) {
+    (remapped as CartItem).offer = _embedded.offer;
+  }
+
+  return remapped as CartItem;
+});
+
+/** @internal */
+export const CartItemsListResponse$inboundSchema: z.ZodType<
+  Paginated<CartItem>
+> = z.object({
+  _embedded: z.object({
+    cart_items: z.array(CartItem$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(
+    v._embedded.cart_items,
+    v.count,
+    v._links,
+  )
+);

package/src/models/commerce/cart.ts

@@ -0,0 +1,128 @@
+/*
+ * Cart model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
+import { Address, Address$inboundSchema } from "./address.js";
+import { CurrencyAmount, CurrencyAmount$inboundSchema } from "../common/amount.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { CartItem, CartItem$inboundSchema } from "./cart-item.js";
+
+export const CartStatus = {
+  Open: "open",
+  Completed: "completed",
+  Abandoned: "abandoned",
+  Expired: "expired",
+} as const;
+export type CartStatus = OpenEnum<typeof CartStatus>;
+
+export const CartType = {
+  Shared: "shared",
+  Default: "default",
+} as const;
+export type CartType = OpenEnum<typeof CartType>;
+
+export type Cart = {
+  resource: string;
+  id: string;
+  status: CartStatus;
+  type: CartType;
+  channelId?: number;
+  languageId?: number | null;
+  customerId?: number | null;
+  userId?: number | null;
+  email?: string;
+  companyName?: string;
+  companyVat?: string;
+  billingAddress?: Address;
+  shippingAddress?: Address;
+  subtotalAmount?: CurrencyAmount;
+  shippingAmount?: CurrencyAmount;
+  discountAmount?: CurrencyAmount;
+  taxAmount?: CurrencyAmount;
+  totalAmount?: CurrencyAmount;
+  country?: string;
+  currency?: string;
+  isShippingRequired?: boolean;
+  shippingMethodId?: number | null;
+  isTaxExempt?: boolean;
+  items?: CartItem[];
+  itemsCount?: number;
+  itemsExists?: boolean;
+  shippingMethod?: unknown;
+  shippingMethodCount?: number;
+  shippingMethodExists?: boolean;
+  totalQuantity?: number;
+  promotionCodes?: string[];
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const CartStatus$inboundSchema: z.ZodType<CartStatus, unknown> = openEnums
+  .inboundSchema(CartStatus);
+/** @internal */
+export const CartType$inboundSchema: z.ZodType<CartType, unknown> = openEnums
+  .inboundSchema(CartType);
+
+/** @internal */
+export const Cart$inboundSchema: z.ZodType<Cart> = z.object({
+  resource: z.string(),
+  id: z.string(),
+  status: CartStatus$inboundSchema,
+  type: CartType$inboundSchema,
+  channelId: z.number().optional(),
+  languageId: z.number().nullable().optional(),
+  customerId: z.number().nullable().optional(),
+  userId: z.number().nullable().optional(),
+  email: z.string().optional(),
+  companyName: z.string().optional(),
+  companyVat: z.string().optional(),
+  billingAddress: Address$inboundSchema.optional(),
+  shippingAddress: Address$inboundSchema.optional(),
+  subtotalAmount: CurrencyAmount$inboundSchema.optional(),
+  shippingAmount: CurrencyAmount$inboundSchema.optional(),
+  discountAmount: CurrencyAmount$inboundSchema.optional(),
+  taxAmount: CurrencyAmount$inboundSchema.optional(),
+  totalAmount: CurrencyAmount$inboundSchema.optional(),
+  country: z.string().optional(),
+  currency: z.string().optional(),
+  isShippingRequired: z.boolean().optional(),
+  shippingMethodId: z.number().nullable().optional(),
+  isTaxExempt: z.boolean().optional(),
+  items: z.array(CartItem$inboundSchema).optional(),
+  itemsCount: z.number().optional(),
+  itemsExists: z.boolean().optional(),
+  shippingMethod: z.any().optional(),
+  shippingMethodCount: z.number().optional(),
+  shippingMethodExists: z.boolean().optional(),
+  totalQuantity: z.number().optional(),
+  promotionCodes: z.array(z.string()).optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => remap$(v, { _links: "links" }) as Cart);
+
+export type CartsListResponse = Paginated<Cart>;
+
+/** @internal */
+export const CartsListResponse$inboundSchema: z.ZodType<
+  CartsListResponse
+> = z.object({
+  _embedded: z.object({
+    carts: z.array(Cart$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(
+    v._embedded.carts,
+    v.count,
+    v._links,
+  )
+);

package/src/models/commerce/category.ts

@@ -0,0 +1,87 @@
+/*
+ * Category model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Tag, Tag$inboundSchema } from "../common/tag.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Route, Route$inboundSchema } from "./route.js";
+
+export type Category = {
+  resource: string;
+  id: number;
+  parentId: number | null;
+  name: string;
+  slug: string;
+  fullSlug: string;
+  description: string;
+  coverImage: string | null;
+  routes: Record<string, Route>;
+  productsCount: number;
+  customFields: unknown[];
+  updatedAt: string;
+  createdAt: string;
+  parent?: Category;
+  children?: Category[];
+  tags?: Tag[];
+  links?: HalLinks;
+};
+
+export type CategoriesListResponse = Paginated<Category>;
+
+/** @internal */
+export const Category$inboundSchema: z.ZodType<Category> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  parentId: z.number().nullable(),
+  name: z.string(),
+  slug: z.string(),
+  fullSlug: z.string(),
+  description: z.string(),
+  coverImage: z.string().nullable(),
+  routes: z.record(z.string(), Route$inboundSchema),
+  productsCount: z.number(),
+  customFields: z.array(z.any()),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    parent: z.lazy(() => Category$inboundSchema).optional(),
+    children: z.array(z.lazy(() => Category$inboundSchema)).optional(),
+    tags: z.array(Tag$inboundSchema).optional(),
+  }).loose().optional(),
+}).transform((v) => {
+  const { _embedded } = v;
+  const remapped = remap$(v, { _links: "links", _embedded: null });
+
+  if (_embedded?.parent !== undefined) {
+    (remapped as Category).parent = _embedded.parent;
+  }
+  if (_embedded?.children !== undefined) {
+    (remapped as Category).children = _embedded.children;
+  }
+  if (_embedded?.tags !== undefined) {
+    (remapped as Category).tags = _embedded.tags;
+  }
+
+  return remapped as Category;
+});
+
+/** @internal */
+export const CategoriesListResponse$inboundSchema: z.ZodType<
+  Paginated<Category>
+> = z.object({
+  _embedded: z.object({
+    categories: z.array(Category$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(
+    v._embedded.categories,
+    v.count,
+    v._links,
+  )
+);

package/src/models/commerce/index.ts

@@ -0,0 +1,13 @@
+/*
+ * Commerce models.
+ */
+
+export * from "./product.js";
+export * from "./category.js";
+export * from "./product-group.js";
+export * from "./product-offer.js";
+export * from "./cart.js";
+export * from "./cart-item.js";
+export * from "./address.js";
+export * from "./money.js";
+export * from "./route.js";

package/src/models/commerce/money.ts

@@ -0,0 +1,24 @@
+/*
+ * Money model.
+ */
+
+import * as z from "zod/v4";
+
+export type Money = {
+  amount: number;
+  formatted: string;
+};
+
+export type PriceMap = Record<string, Money>;
+
+/** @internal */
+export const Money$inboundSchema: z.ZodType<Money> = z.object({
+  amount: z.number(),
+  formatted: z.string(),
+});
+
+/** @internal */
+export const PriceMap$inboundSchema: z.ZodType<PriceMap> = z.record(
+  z.string(),
+  Money$inboundSchema,
+);

package/src/models/commerce/product-group.ts

@@ -0,0 +1,23 @@
+/*
+ * Product group model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type ProductGroup = {
+  resource?: string;
+  id?: number;
+  name?: string;
+  links?: HalLinks;
+  [key: string]: unknown;
+};
+
+/** @internal */
+export const ProductGroup$inboundSchema: z.ZodType<ProductGroup> = z.object({
+  resource: z.string().optional(),
+  id: z.number().optional(),
+  name: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+}).loose().transform((v) => remap$(v, { _links: "links" }) as ProductGroup);

package/src/models/commerce/product-offer.ts

@@ -0,0 +1,31 @@
+/*
+ * Product offer model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { PriceMap, PriceMap$inboundSchema } from "./money.js";
+
+export type ProductOffer = {
+  resource: string;
+  id: number;
+  productId: number;
+  type: string;
+  intervalId?: number | null;
+  quantity: number;
+  prices: PriceMap;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const ProductOffer$inboundSchema: z.ZodType<ProductOffer> = z.object({
+  resource: z.string(),
+  id: z.number(),
+  productId: z.number(),
+  type: z.string(),
+  intervalId: z.number().nullable().optional(),
+  quantity: z.number(),
+  prices: PriceMap$inboundSchema,
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => remap$(v, { _links: "links" }) as ProductOffer);