@ominity/api-typescript 1.1.5 → 1.2.0

package/src/models/cms/content-type.ts

@@ -0,0 +1,75 @@
+/*
+ * CMS Content Type model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+import {
+    ContentTypeField,
+    ContentTypeField$inboundSchema,
+} from "./content-type-field.js";
+
+export type ContentTypeRouteConfiguration = {
+    name: string;
+    parameterFieldSlugs: Array<string>;
+};
+
+export type ContentType = {
+    resource: string;
+    id: number;
+    name: string;
+    slug: string;
+    resourceKey: string | null;
+    singularTitle: string | null;
+    pluralTitle: string | null;
+    description: string | null;
+    translatable: boolean;
+    routable: boolean;
+    route: ContentTypeRouteConfiguration | null;
+    showInNavigation: boolean;
+    navigationGroup: string | null;
+    formLayout: Record<string, any> | Array<any> | null;
+    fields?: Array<ContentTypeField>;
+    updatedAt: string | null;
+    createdAt: string | null;
+    links?: HalLinks;
+};
+
+/** @internal */
+export const ContentTypeRouteConfiguration$inboundSchema: z.ZodType<
+    ContentTypeRouteConfiguration
+> = z.object({
+    name: z.string(),
+    parameterFieldSlugs: z.array(z.string()),
+});
+
+/** @internal */
+export const ContentType$inboundSchema: z.ZodType<ContentType> = z.object({
+    resource: z.string(),
+    id: z.number(),
+    name: z.string(),
+    slug: z.string(),
+    resourceKey: z.string().nullable(),
+    singularTitle: z.string().nullable(),
+    pluralTitle: z.string().nullable(),
+    description: z.string().nullable(),
+    translatable: z.boolean(),
+    routable: z.boolean(),
+    route: ContentTypeRouteConfiguration$inboundSchema.nullable(),
+    showInNavigation: z.boolean(),
+    navigationGroup: z.string().nullable(),
+    formLayout: z.union([
+        z.record(z.string(), z.any()),
+        z.array(z.any()),
+        z.null(),
+    ]),
+    fields: z.array(ContentTypeField$inboundSchema).optional(),
+    updatedAt: z.string().nullable(),
+    createdAt: z.string().nullable(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "_links": "links",
+    }) as ContentType;
+});

package/src/models/cms/index.ts

@@ -3,6 +3,6 @@ export * from "./layout.js";
 export * from "./page.js";
 export * from "./menu.js";
 export * from "./page-component.js";
-
-
-
+export * from "./content-type-field.js";
+export * from "./content-type.js";
+export * from "./content-entry.js";

package/src/models/commerce/route.ts

@@ -4,12 +4,12 @@
 
 import * as z from "zod/v4";
 
-export type RouteParameters = Record<string, string | number>;
+export type RouteParameters = Record<string, string | number | boolean | null>;
 
 export type Route = {
   resource: string;
   name: string;
-  locale: string;
+  locale: string | null;
   parameters: RouteParameters;
 };
 
@@ -17,13 +17,13 @@ export type Route = {
 export const RouteParameters$inboundSchema: z.ZodType<RouteParameters> = z
   .record(
     z.string(),
-    z.union([z.string(), z.number()]),
+    z.union([z.string(), z.number(), z.boolean(), z.null()]),
   );
 
 /** @internal */
 export const Route$inboundSchema: z.ZodType<Route> = z.object({
   resource: z.string(),
   name: z.string(),
-  locale: z.string(),
+  locale: z.string().nullable(),
   parameters: RouteParameters$inboundSchema,
 });

package/src/models/index.ts

@@ -1,5 +1,6 @@
 export * from "./security.js";
 export * from "./channels/index.js";
+export * from "./cms/index.js";
 export * from "./common/index.js";
 export * from "./commerce/index.js";
 export * from "./localization/index.js";

package/src/models/operations/cms-content-types.ts

@@ -0,0 +1,74 @@
+/*
+ * CMS Content Types operations.
+ */
+
+import * as z from "zod/v4";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { ContentType, ContentType$inboundSchema } from "../cms/content-type.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+
+export type ListContentTypesRequest = {
+    filterId?: number | undefined;
+    filterNameSingular?: string | undefined;
+    filterNamePlural?: string | undefined;
+    filterSlug?: string | undefined;
+    filterResourceKey?: string | undefined;
+    include?: string | undefined;
+    sort?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+export type ListContentTypesResponse = Paginated<ContentType>;
+
+/** @internal */
+export const ListContentTypesRequest$outboundSchema: z.ZodType<
+    ListContentTypesRequest
+> = z.object({
+    filterId: z.number().optional(),
+    filterNameSingular: z.string().optional(),
+    filterNamePlural: z.string().optional(),
+    filterSlug: z.string().optional(),
+    filterResourceKey: z.string().optional(),
+    include: z.string().optional(),
+    sort: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListContentTypesResponse$inboundSchema: z.ZodType<
+    ListContentTypesResponse
+> = z.object({
+    _embedded: z.object({
+        content_types: z.array(ContentType$inboundSchema),
+    }),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) =>
+    buildPaginated(
+        v._embedded.content_types,
+        v.count,
+        v._links,
+    )
+);
+
+export type GetContentTypeRequest = {
+    id: number;
+    include?: string | undefined;
+};
+
+export type GetContentTypeResponse = ContentType;
+
+/** @internal */
+export const GetContentTypeRequest$outboundSchema: z.ZodType<
+    GetContentTypeRequest
+> = z.object({
+    id: z.number(),
+    include: z.string().optional(),
+});
+
+/** @internal */
+export const GetContentTypeResponse$inboundSchema: z.ZodType<
+    GetContentTypeResponse
+> = ContentType$inboundSchema;

package/src/models/operations/cms-content.ts

@@ -0,0 +1,132 @@
+/*
+ * CMS Content operations.
+ */
+
+import * as z from "zod/v4";
+import { buildPaginated, Paginated } from "../pagination.js";
+import { ContentEntry, ContentEntry$inboundSchema } from "../cms/content-entry.js";
+import { HalLinks$inboundSchema } from "../hal.js";
+
+export type ListContentRequest = {
+    slug: string;
+    filterId?: string | undefined;
+    sort?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+};
+
+export type ListContentResponse<TEntry extends ContentEntry = ContentEntry> = Paginated<TEntry>;
+
+/** @internal */
+export const ListContentRequest$outboundSchema: z.ZodType<
+    ListContentRequest
+> = z.object({
+    slug: z.string(),
+    filterId: z.string().optional(),
+    sort: z.string().optional(),
+    page: z.number().optional(),
+    limit: z.number().optional(),
+});
+
+/** @internal */
+export const ListContentResponse$inboundSchema: z.ZodType<
+    ListContentResponse
+> = z.object({
+    _embedded: z.record(z.string(), z.array(ContentEntry$inboundSchema)),
+    count: z.number(),
+    _links: HalLinks$inboundSchema.optional(),
+}).transform((v) => {
+    const entries = Object.values(v._embedded)[0] ?? [];
+
+    return buildPaginated(
+        entries,
+        v.count,
+        v._links,
+    );
+});
+
+export type GetContentRequest = {
+    slug: string;
+    id: string;
+};
+
+export type GetContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const GetContentRequest$outboundSchema: z.ZodType<
+    GetContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+});
+
+/** @internal */
+export const GetContentResponse$inboundSchema: z.ZodType<
+    GetContentResponse
+> = ContentEntry$inboundSchema;
+
+export type CreateContentRequest = {
+    slug: string;
+    data: Record<string, any>;
+};
+
+export type CreateContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const CreateContentRequest$outboundSchema: z.ZodType<
+    CreateContentRequest
+> = z.object({
+    slug: z.string(),
+    data: z.record(z.string(), z.any()),
+});
+
+/** @internal */
+export const CreateContentResponse$inboundSchema: z.ZodType<
+    CreateContentResponse
+> = ContentEntry$inboundSchema;
+
+export type UpdateContentRequest = {
+    slug: string;
+    id: string;
+    data: Record<string, any>;
+};
+
+export type UpdateContentResponse<TEntry extends ContentEntry = ContentEntry> = TEntry;
+
+/** @internal */
+export const UpdateContentRequest$outboundSchema: z.ZodType<
+    UpdateContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+    data: z.record(z.string(), z.any()),
+});
+
+/** @internal */
+export const UpdateContentResponse$inboundSchema: z.ZodType<
+    UpdateContentResponse
+> = ContentEntry$inboundSchema;
+
+export type DeleteContentRequest = {
+    slug: string;
+    id: string;
+};
+
+export type DeleteContentResponse = {
+    deleted: boolean;
+};
+
+/** @internal */
+export const DeleteContentRequest$outboundSchema: z.ZodType<
+    DeleteContentRequest
+> = z.object({
+    slug: z.string(),
+    id: z.string(),
+});
+
+/** @internal */
+export const DeleteContentResponse$inboundSchema: z.ZodType<
+    DeleteContentResponse
+> = z.object({
+    deleted: z.boolean(),
+});

package/src/models/operations/index.ts

@@ -2,7 +2,9 @@ export * from "./commerce-products.js";
 export * from "./commerce-categories.js";
 export * from "./commerce-carts.js";
 export * from "./commerce-cart-items.js";
+export * from "./cms-content.js";
 export * from "./cms-components.js";
+export * from "./cms-content-types.js";
 export * from "./cms-layouts.js";
 export * from "./cms-pages.js";
 export * from "./cms-menus.js";

package/src/sdk/cms/content-types.ts

@@ -0,0 +1,25 @@
+/*
+ * CMS Content Types SDK.
+ */
+
+import { contentTypesList } from "../../funcs/cms/contentTypesList.js";
+import { contentTypesGet } from "../../funcs/cms/contentTypesGet.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class ContentTypes extends ClientSDK {
+    async list(
+        request?: operations.ListContentTypesRequest | undefined,
+        options?: RequestOptions,
+    ): Promise<operations.ListContentTypesResponse> {
+        return unwrapAsync(contentTypesList(this, request, options));
+    }
+
+    async get(
+        request: operations.GetContentTypeRequest,
+        options?: RequestOptions,
+    ): Promise<operations.GetContentTypeResponse> {
+        return unwrapAsync(contentTypesGet(this, request, options));
+    }
+}

package/src/sdk/cms/content.ts

@@ -0,0 +1,50 @@
+/*
+ * CMS Content SDK.
+ */
+
+import { contentList } from "../../funcs/cms/contentList.js";
+import { contentGet } from "../../funcs/cms/contentGet.js";
+import { contentCreate } from "../../funcs/cms/contentCreate.js";
+import { contentUpdate } from "../../funcs/cms/contentUpdate.js";
+import { contentDelete } from "../../funcs/cms/contentDelete.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { ContentEntry } from "../../models/cms/content-entry.js";
+import * as operations from "../../models/operations/index.js";
+import { unwrapAsync } from "../../types/fp.js";
+
+export class Content extends ClientSDK {
+    async list<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.ListContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.ListContentResponse<TEntry>> {
+        return unwrapAsync(contentList<TEntry>(this, request, options));
+    }
+
+    async get<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.GetContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.GetContentResponse<TEntry>> {
+        return unwrapAsync(contentGet<TEntry>(this, request, options));
+    }
+
+    async create<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.CreateContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.CreateContentResponse<TEntry>> {
+        return unwrapAsync(contentCreate<TEntry>(this, request, options));
+    }
+
+    async update<TEntry extends ContentEntry = ContentEntry>(
+        request: operations.UpdateContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.UpdateContentResponse<TEntry>> {
+        return unwrapAsync(contentUpdate<TEntry>(this, request, options));
+    }
+
+    async delete(
+        request: operations.DeleteContentRequest,
+        options?: RequestOptions,
+    ): Promise<operations.DeleteContentResponse> {
+        return unwrapAsync(contentDelete(this, request, options));
+    }
+}

package/src/sdk/cms/index.ts

@@ -4,17 +4,23 @@
 
 import { ClientSDK } from "../../lib/sdks.js";
 import { Components } from "./components.js";
+import { Content } from "./content.js";
+import { ContentTypes } from "./content-types.js";
 import { Layouts } from "./layouts.js";
 import { Pages } from "./pages.js";
 import { Menus } from "./menus.js";
 
 export { Components } from "./components.js";
+export { Content } from "./content.js";
+export { ContentTypes } from "./content-types.js";
 export { Layouts } from "./layouts.js";
 export { Pages } from "./pages.js";
 export { Menus } from "./menus.js";
 
 export class Cms extends ClientSDK {
     private _components?: Components;
+    private _content?: Content;
+    private _contentTypes?: ContentTypes;
     private _layouts?: Layouts;
     private _pages?: Pages;
     private _menus?: Menus;
@@ -23,6 +29,14 @@ export class Cms extends ClientSDK {
         return (this._components ??= new Components(this._options));
     }
 
+    get content(): Content {
+        return (this._content ??= new Content(this._options));
+    }
+
+    get contentTypes(): ContentTypes {
+        return (this._contentTypes ??= new ContentTypes(this._options));
+    }
+
     get layouts(): Layouts {
         return (this._layouts ??= new Layouts(this._options));
     }

package/src/sdk/index.ts

@@ -1,2 +1,3 @@
 
 export * from "./sdk.js";
+export * from "./tracking/index.js";

package/src/sdk/sdk.ts

@@ -10,6 +10,7 @@ import { OAuth2 } from "./oauth2.js";
 import { Settings } from "./settings/index.js";
 import { Users } from "./users/index.js";
 import { Admins } from "./admins.js";
+import { Tracking } from "./tracking/index.js";
 import type { SDKOptions } from "../lib/config.js";
 import type {
   OminityModuleInput,
@@ -66,6 +67,11 @@ export class Ominity extends ClientSDK {
     return (this._http ??= new Http(this._options));
   }
 
+  private _tracking?: Tracking;
+  get tracking(): Tracking {
+    return (this._tracking ??= new Tracking(this.http));
+  }
+
   private _localization?: Localization;
   get localization(): Localization {
     return (this._localization ??= new Localization(this._options));

package/src/sdk/tracking/events.ts

@@ -0,0 +1,200 @@
+/*
+ * Tracking Events SDK.
+ */
+
+import { RequestOptions } from "../../lib/sdks.js";
+import { Http } from "../http.js";
+
+export type TrackingEventName =
+  | "page_view"
+  | "product_view"
+  | "cart_view"
+  | "add_to_cart"
+  | "remove_from_cart"
+  | "checkout_started"
+  | "purchase"
+  | "button_click"
+  | string;
+
+export type TrackingEventMetadata = Readonly<Record<string, unknown>>;
+export type TrackingEventUtm = Readonly<Record<string, string>>;
+
+export interface TrackEventRequest {
+  readonly event: TrackingEventName;
+  readonly timestamp?: string | Date;
+  readonly title?: string;
+  readonly url?: string;
+  readonly metadata?: TrackingEventMetadata;
+  readonly visitorId?: string;
+  readonly userId?: number;
+  readonly referrer?: string;
+  readonly utm?: TrackingEventUtm;
+}
+
+export interface TrackEventResponse {
+  readonly success: boolean;
+  readonly visitorId: string;
+}
+
+type MutableTrackingPayload = {
+  event: string;
+  timestamp: string;
+  title?: string;
+  url?: string;
+  metadata?: TrackingEventMetadata;
+  visitorId?: string;
+  userId?: number;
+  referrer?: string;
+  utm?: TrackingEventUtm;
+};
+
+function asNonEmptyString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return;
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function asValidDate(value: Date): Date | undefined {
+  if (!Number.isFinite(value.getTime())) {
+    return;
+  }
+
+  return value;
+}
+
+function normalizeTimestamp(value: string | Date | undefined): string {
+  if (value instanceof Date) {
+    const parsed = asValidDate(value);
+    if (parsed) {
+      return parsed.toISOString();
+    }
+  } else if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+
+  return new Date().toISOString();
+}
+
+function normalizeUtm(value: unknown): TrackingEventUtm | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+
+  const normalized: Record<string, string> = {};
+  for (const [key, raw] of Object.entries(value)) {
+    const trimmed = asNonEmptyString(raw);
+    if (trimmed) {
+      normalized[key] = trimmed;
+    }
+  }
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeMetadata(value: unknown): TrackingEventMetadata | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+
+  return value as TrackingEventMetadata;
+}
+
+function normalizeTrackEventPayload(input: TrackEventRequest): MutableTrackingPayload {
+  const eventName = asNonEmptyString(input.event);
+  if (!eventName) {
+    throw new Error("Tracking event name is required.");
+  }
+
+  const payload: MutableTrackingPayload = {
+    event: eventName,
+    timestamp: normalizeTimestamp(input.timestamp),
+  };
+
+  const title = asNonEmptyString(input.title);
+  if (title) {
+    payload.title = title;
+  }
+
+  const url = asNonEmptyString(input.url);
+  if (url) {
+    payload.url = url;
+  }
+
+  const metadata = normalizeMetadata(input.metadata);
+  if (metadata) {
+    payload.metadata = metadata;
+  }
+
+  const visitorId = asNonEmptyString(input.visitorId);
+  if (visitorId) {
+    payload.visitorId = visitorId;
+  }
+
+  if (typeof input.userId === "number" && Number.isFinite(input.userId)) {
+    payload.userId = Math.trunc(input.userId);
+  }
+
+  const referrer = asNonEmptyString(input.referrer);
+  if (referrer) {
+    payload.referrer = referrer;
+  }
+
+  const utm = normalizeUtm(input.utm);
+  if (utm) {
+    payload.utm = utm;
+  }
+
+  return payload;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  if (typeof value === "object" && value !== null) {
+    return value as Record<string, unknown>;
+  }
+
+  return {};
+}
+
+function normalizeTrackEventResponse(payload: unknown): TrackEventResponse {
+  const record = asRecord(payload);
+  const visitorId = asNonEmptyString(record["visitorId"]) ?? "";
+  const success = record["success"] === true;
+
+  return {
+    success,
+    visitorId,
+  };
+}
+
+export class TrackingEvents {
+  readonly #http: Http;
+
+  constructor(http: Http) {
+    this.#http = http;
+  }
+
+  async create(
+    request: TrackEventRequest,
+    options?: RequestOptions,
+  ): Promise<TrackEventResponse> {
+    const response = await this.#http.post("/tracking/events", {
+      ...options,
+      json: normalizeTrackEventPayload(request),
+    });
+
+    return normalizeTrackEventResponse(await response.json());
+  }
+
+  async track(
+    request: TrackEventRequest,
+    options?: RequestOptions,
+  ): Promise<TrackEventResponse> {
+    return this.create(request, options);
+  }
+}