@ominity/api-typescript 0.0.3 → 1.1.0

package/src/lib/encodings.ts

@@ -438,7 +438,7 @@ type BulkQueryEncoder = (
 ) => string;
 
 export function queryEncoder(f: QueryEncoder): BulkQueryEncoder {
-  const bulkEncode = function(
+  const bulkEncode = function (
     values: Record<string, unknown>,
     options?: QueryEncoderOptions,
   ): string {
@@ -474,6 +474,7 @@ export const encodeFormQuery = queryEncoder(encodeForm);
 export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+export const encodeSimpleQuery = queryEncoder(encodeSimple);
 
 export function appendForm(
   fd: FormData,

package/src/lib/url.ts

@@ -28,3 +28,35 @@ export function pathToFunc(
     });
   };
 }
+
+/**
+ * Returns a copy of a base URL with the configured API version suffix removed.
+ * Useful for endpoints that are mounted outside `/api/{version}`.
+ */
+export function baseURLWithoutAPIVersion(
+  baseURL: string | URL | null | undefined,
+  apiVersion: string | undefined,
+): URL | undefined {
+  if (!baseURL) {
+    return undefined;
+  }
+
+  const normalizedVersion = apiVersion ?? "v1";
+  const url = new URL(baseURL.toString());
+
+  const pathname = url.pathname.replace(/\/+$/, "");
+  const versionSuffix = normalizedVersion ? `/${normalizedVersion}` : "";
+
+  if (versionSuffix && pathname.endsWith(versionSuffix)) {
+    const nextPath = pathname.slice(0, -versionSuffix.length);
+    url.pathname = `${nextPath || "/"}`;
+  } else {
+    url.pathname = `${pathname || "/"}`;
+  }
+
+  if (!url.pathname.endsWith("/")) {
+    url.pathname = `${url.pathname}/`;
+  }
+
+  return url;
+}

package/src/models/channels/channel-domain.ts

@@ -0,0 +1,79 @@
+/*
+ * Channel domain model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { Currency, Currency$inboundSchema } from "../commerce/currency.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Language, Language$inboundSchema } from "../localization/language.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Channel, Channel$inboundSchema } from "./channel.js";
+
+export type ChannelDomain = {
+  resource: "channel_domain";
+  id: number;
+  channelId: number;
+  url: string;
+  languageId?: number | null;
+  currencyId?: number | null;
+  hreflangLocaleOnly: boolean;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+  channel?: Channel;
+  language?: Language;
+  currency?: Currency;
+};
+
+/** @internal */
+export const ChannelDomain$inboundSchema: z.ZodType<ChannelDomain> = z.object({
+  resource: z.literal("channel_domain"),
+  id: z.number().int(),
+  channelId: z.number().int(),
+  url: z.string(),
+  languageId: z.number().int().nullable().optional(),
+  currencyId: z.number().int().nullable().optional(),
+  hreflangLocaleOnly: z.boolean(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    channel: z.lazy(() => Channel$inboundSchema).optional(),
+    language: z.lazy(() => Language$inboundSchema).optional(),
+    currency: z.lazy(() => Currency$inboundSchema).optional(),
+  }).optional(),
+})
+  .loose()
+  .transform((v) => {
+    const out = remap$(v, { _links: "links" }) as ChannelDomain;
+    if (v._embedded?.channel) {
+      out.channel = v._embedded.channel;
+    }
+    if (v._embedded?.language) {
+      out.language = v._embedded.language;
+    }
+    if (v._embedded?.currency) {
+      out.currency = v._embedded.currency;
+    }
+    return out;
+  });
+
+export type ChannelDomainsListResponse = Paginated<ChannelDomain>;
+
+/** @internal */
+export const ChannelDomainsListResponse$inboundSchema: z.ZodType<
+  ChannelDomainsListResponse
+> = z.object({
+  _embedded: z.object({
+    domains: z.array(ChannelDomain$inboundSchema).optional(),
+    channel_domains: z.array(ChannelDomain$inboundSchema).optional(),
+  }).refine((embedded) =>
+    Array.isArray(embedded.domains) || Array.isArray(embedded.channel_domains)
+  ),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+  const items = v._embedded.domains ?? v._embedded.channel_domains ?? [];
+  return buildPaginated(items, v.count, v["_links"]);
+});

package/src/models/channels/channel-system-setting.ts

@@ -0,0 +1,30 @@
+/*
+ * Channel system setting model.
+ */
+
+import * as z from "zod/v4";
+
+export type ChannelSystemSetting = {
+  resource: "channel_system_setting";
+  id: number;
+  channelId: number;
+  group: string;
+  name: string;
+  payload?: Record<string, unknown> | unknown[] | undefined;
+  updatedAt?: string;
+  createdAt?: string;
+};
+
+/** @internal */
+export const ChannelSystemSetting$inboundSchema: z.ZodType<
+  ChannelSystemSetting
+> = z.object({
+  resource: z.literal("channel_system_setting"),
+  id: z.number().int(),
+  channelId: z.number().int(),
+  group: z.string(),
+  name: z.string(),
+  payload: z.union([z.record(z.string(), z.any()), z.array(z.any())]).optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+}).loose() as unknown as z.ZodType<ChannelSystemSetting>;

package/src/models/channels/channel-type.ts

@@ -0,0 +1,71 @@
+/*
+ * Channel type model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Channel, Channel$inboundSchema } from "./channel.js";
+
+export type ChannelType = {
+  resource: "channel_type";
+  id: number;
+  technicalName: string;
+  name: string;
+  manufacturer?: string | null;
+  summary?: string | null;
+  description?: string | null;
+  coverUrl?: string | null;
+  icon?: string | null;
+  screenshotUrls?: string[];
+  isAvailable: boolean;
+  updatedAt?: string;
+  createdAt?: string;
+  links?: HalLinks;
+  channels?: Channel[];
+};
+
+/** @internal */
+export const ChannelType$inboundSchema: z.ZodType<ChannelType> = z.object({
+  resource: z.literal("channel_type"),
+  id: z.number().int(),
+  technicalName: z.string(),
+  name: z.string(),
+  manufacturer: z.string().nullable().optional(),
+  summary: z.string().nullable().optional(),
+  description: z.string().nullable().optional(),
+  coverUrl: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  screenshotUrls: z.array(z.string()).optional(),
+  isAvailable: z.boolean(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    channels: z.array(z.lazy(() => Channel$inboundSchema)).optional(),
+  }).optional(),
+})
+  .loose()
+  .transform((v) => {
+    const out = remap$(v, { _links: "links" }) as ChannelType;
+    if (v._embedded?.channels) {
+      out.channels = v._embedded.channels;
+    }
+    return out;
+  });
+
+export type ChannelTypesListResponse = Paginated<ChannelType>;
+
+/** @internal */
+export const ChannelTypesListResponse$inboundSchema: z.ZodType<
+  ChannelTypesListResponse
+> = z.object({
+  _embedded: z.object({
+    channel_types: z.array(ChannelType$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+  buildPaginated(v._embedded.channel_types, v.count, v["_links"])
+);

package/src/models/channels/channel.ts

@@ -0,0 +1,166 @@
+/*
+ * Channel model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { Currency, Currency$inboundSchema } from "../commerce/currency.js";
+import { ShippingMethod, ShippingMethod$inboundSchema } from "../commerce/shipping-method.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import { Language, Language$inboundSchema } from "../localization/language.js";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { Country, Country$inboundSchema } from "../settings/country.js";
+import { PaymentMethod, PaymentMethod$inboundSchema } from "../settings/payment-method.js";
+import { ChannelDomain, ChannelDomain$inboundSchema } from "./channel-domain.js";
+import {
+  ChannelSystemSetting,
+  ChannelSystemSetting$inboundSchema,
+} from "./channel-system-setting.js";
+import { ChannelType, ChannelType$inboundSchema } from "./channel-type.js";
+
+export type Channel = {
+  resource: "channel";
+  id: number;
+  typeId: number;
+  name: string;
+  identifier: string;
+  defaultLanguageId?: number | null;
+  defaultCountryId?: number | null;
+  defaultCurrencyId?: number | null;
+  defaultPaymentMethodId?: number | null;
+  defaultShippingMethodId?: string | null;
+  hreflangDefaultDomainId?: number | null;
+  taxCalculationType?: string | null;
+  bindCustomersToChannel: boolean;
+  isActive: boolean;
+  isMaintenance: boolean;
+  maintenanceIpWhitelist?: string[];
+  configuration?: Record<string, unknown> | unknown[];
+  updatedAt?: string;
+  createdAt?: string;
+  deletedAt?: string | null;
+  links?: HalLinks;
+  type?: ChannelType;
+  domains?: ChannelDomain[];
+  hreflangDefaultDomain?: ChannelDomain | null;
+  defaultLanguage?: Language | null;
+  defaultCountry?: Country | null;
+  defaultCurrency?: Currency | null;
+  defaultPaymentMethod?: PaymentMethod | null;
+  defaultShippingMethod?: ShippingMethod | null;
+  languages?: Language[];
+  countries?: Country[];
+  currencies?: Currency[];
+  paymentMethods?: PaymentMethod[];
+  shippingMethods?: ShippingMethod[];
+  systemSettings?: ChannelSystemSetting[];
+};
+
+/** @internal */
+export const Channel$inboundSchema: z.ZodType<Channel> = z.object({
+  resource: z.literal("channel"),
+  id: z.number().int(),
+  typeId: z.number().int(),
+  name: z.string(),
+  identifier: z.string(),
+  defaultLanguageId: z.number().int().nullable().optional(),
+  defaultCountryId: z.number().int().nullable().optional(),
+  defaultCurrencyId: z.number().int().nullable().optional(),
+  defaultPaymentMethodId: z.number().int().nullable().optional(),
+  defaultShippingMethodId: z.string().nullable().optional(),
+  hreflangDefaultDomainId: z.number().int().nullable().optional(),
+  taxCalculationType: z.string().nullable().optional(),
+  bindCustomersToChannel: z.boolean(),
+  isActive: z.boolean(),
+  isMaintenance: z.boolean(),
+  maintenanceIpWhitelist: z.array(z.string()).optional(),
+  configuration: z.union([z.record(z.string(), z.any()), z.array(z.any())])
+    .optional(),
+  updatedAt: z.string().optional(),
+  createdAt: z.string().optional(),
+  deletedAt: z.string().nullable().optional(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    type: z.lazy(() => ChannelType$inboundSchema).optional(),
+    domains: z.array(z.lazy(() => ChannelDomain$inboundSchema)).optional(),
+    hreflang_default_domain: z.lazy(() => ChannelDomain$inboundSchema).nullable()
+      .optional(),
+    default_language: z.lazy(() => Language$inboundSchema).nullable().optional(),
+    default_country: z.lazy(() => Country$inboundSchema).nullable().optional(),
+    default_currency: z.lazy(() => Currency$inboundSchema).nullable().optional(),
+    default_payment_method: z.lazy(() => PaymentMethod$inboundSchema).nullable()
+      .optional(),
+    default_shipping_method: z.lazy(() => ShippingMethod$inboundSchema)
+      .nullable().optional(),
+    languages: z.array(z.lazy(() => Language$inboundSchema)).optional(),
+    countries: z.array(z.lazy(() => Country$inboundSchema)).optional(),
+    currencies: z.array(z.lazy(() => Currency$inboundSchema)).optional(),
+    payment_methods: z.array(z.lazy(() => PaymentMethod$inboundSchema))
+      .optional(),
+    shipping_methods: z.array(z.lazy(() => ShippingMethod$inboundSchema))
+      .optional(),
+    system_settings: z.array(z.lazy(() => ChannelSystemSetting$inboundSchema))
+      .optional(),
+  }).optional(),
+})
+  .loose()
+  .transform((v) => {
+    const out = remap$(v, { _links: "links" }) as Channel;
+    const embedded = v["_embedded"];
+    if (embedded?.type) {
+      out.type = embedded.type;
+    }
+    if (embedded?.domains) {
+      out.domains = embedded.domains;
+    }
+    if (typeof embedded?.hreflang_default_domain !== "undefined") {
+      out.hreflangDefaultDomain = embedded.hreflang_default_domain;
+    }
+    if (typeof embedded?.default_language !== "undefined") {
+      out.defaultLanguage = embedded.default_language;
+    }
+    if (typeof embedded?.default_country !== "undefined") {
+      out.defaultCountry = embedded.default_country;
+    }
+    if (typeof embedded?.default_currency !== "undefined") {
+      out.defaultCurrency = embedded.default_currency;
+    }
+    if (typeof embedded?.default_payment_method !== "undefined") {
+      out.defaultPaymentMethod = embedded.default_payment_method;
+    }
+    if (typeof embedded?.default_shipping_method !== "undefined") {
+      out.defaultShippingMethod = embedded.default_shipping_method;
+    }
+    if (embedded?.languages) {
+      out.languages = embedded.languages;
+    }
+    if (embedded?.countries) {
+      out.countries = embedded.countries;
+    }
+    if (embedded?.currencies) {
+      out.currencies = embedded.currencies;
+    }
+    if (embedded?.payment_methods) {
+      out.paymentMethods = embedded.payment_methods;
+    }
+    if (embedded?.shipping_methods) {
+      out.shippingMethods = embedded.shipping_methods;
+    }
+    if (embedded?.system_settings) {
+      out.systemSettings = embedded.system_settings;
+    }
+    return out;
+  });
+
+export type ChannelsListResponse = Paginated<Channel>;
+
+/** @internal */
+export const ChannelsListResponse$inboundSchema: z.ZodType<
+  ChannelsListResponse
+> = z.object({
+  _embedded: z.object({
+    channels: z.array(Channel$inboundSchema),
+  }),
+  count: z.number(),
+  _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => buildPaginated(v._embedded.channels, v.count, v["_links"]));

package/src/models/channels/index.ts

@@ -0,0 +1,8 @@
+/*
+ * Channels models.
+ */
+
+export * from "./channel.js";
+export * from "./channel-type.js";
+export * from "./channel-domain.js";
+export * from "./channel-system-setting.js";

package/src/models/cms/component.ts

@@ -0,0 +1,36 @@
+/*
+ * CMS Component model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Component = {
+    id: number;
+    slug: string;
+    name: string;
+    description: string;
+    type: string;
+    createdAt: string;
+    updatedAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const Component$inboundSchema: z.ZodType<Component> = z.object({
+    id: z.number(),
+    slug: z.string(),
+    name: z.string(),
+    description: z.string(),
+    type: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "updated_at": "updatedAt",
+        "_links": "links",
+    }) as Component;
+});

package/src/models/cms/index.ts

@@ -0,0 +1,8 @@
+export * from "./component.js";
+export * from "./layout.js";
+export * from "./page.js";
+export * from "./menu.js";
+export * from "./page-component.js";
+
+
+

package/src/models/cms/layout.ts

@@ -0,0 +1,30 @@
+/*
+ * CMS Layout model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Layout = {
+    resource: string;
+    id: number;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const Layout$inboundSchema: z.ZodType<Layout> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as Layout;
+});

package/src/models/cms/menu.ts

@@ -0,0 +1,32 @@
+/*
+ * CMS Menu model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Menu = {
+    resource: string;
+    id: number;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const Menu$inboundSchema: z.ZodType<Menu> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    slug: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as Menu;
+});

package/src/models/cms/page-component.ts

@@ -0,0 +1,38 @@
+/*
+ * CMS Page Component model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type PageComponent = {
+    resource: string;
+    id: number;
+    pageId: number;
+    componentId: number;
+    order: number;
+    parameters: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const PageComponent$inboundSchema: z.ZodType<PageComponent> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    pageId: z.number(),
+    componentId: z.number(),
+    order: z.number(),
+    parameters: z.record(z.string(), z.any()),
+    created_at: z.string(),
+    updated_at: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "updated_at": "updatedAt",
+        "_links": "links",
+    }) as PageComponent;
+});

package/src/models/cms/page.ts

@@ -0,0 +1,40 @@
+/*
+ * CMS Page model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type Page = {
+    resource: string;
+    id: number;
+    slug: string;
+    title: string;
+    description: string;
+    type: string;
+    published: boolean;
+    createdAt: string;
+    updatedAt: string;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const Page$inboundSchema: z.ZodType<Page> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    slug: z.string(),
+    title: z.string(),
+    description: z.string(),
+    type: z.string(),
+    published: z.boolean(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "updated_at": "updatedAt",
+        "_links": "links",
+    }) as Page;
+});

package/src/models/commerce/address.ts

@@ -1,30 +1,43 @@
 /*
- * Address model.
+ * Commerce 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;
+  firstName: string;
+  lastName: string;
+  street: string;
+  number: string;
+  additional: string;
+  postalCode: string;
+  city: string;
+  region: string;
+  country: string;
 };
 
 /** @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(),
+  firstName: z.string(),
+  lastName: z.string(),
+  street: z.string(),
+  number: z.string(),
+  additional: z.string(),
+  postalCode: z.string(),
+  city: z.string(),
+  region: z.string(),
+  country: z.string(),
+});
+
+/** @internal */
+export const Address$outboundSchema: z.ZodType<Address> = z.object({
+  firstName: z.string(),
+  lastName: z.string(),
+  street: z.string(),
+  number: z.string(),
+  additional: z.string(),
+  postalCode: z.string(),
+  city: z.string(),
+  region: z.string(),
+  country: z.string(),
 });