@ominity/api-typescript 1.3.0 → 1.4.0

package/src/funcs/commerce/customerUsersList.ts

@@ -0,0 +1,174 @@
+/*
+ * List customer users.
+ */
+
+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 { applyPaginationParams } from "../../models/pagination.js";
+import { APICall, APIPromise } from "../../types/async.js";
+import { OK, Result } from "../../types/fp.js";
+
+export function customerUsersList(
+  client: ClientSDK,
+  request: operations.ListCustomerUsersRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.ListCustomerUsersResponse,
+    | 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.ListCustomerUsersRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.ListCustomerUsersResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.ListCustomerUsersRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = `/commerce/customers/${payload.customerId}/users`;
+  const baseQuery = encodeFormQuery({
+    sort: payload.sort,
+    page: payload.page,
+    limit: payload.limit,
+  });
+  const filterQuery = payload.filter != null
+    ? encodeDeepObjectQuery({ filter: payload.filter })
+    : undefined;
+  const query = queryJoin(baseQuery, filterQuery);
+
+  const headers = new Headers({ Accept: "application/hal+json" });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "customer.users.list",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["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: ["400", "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.ListCustomerUsersResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.ListCustomerUsersResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [OK(applyPaginationParams(result.value, payload)), { status: "complete", request: req, response }];
+}
+

package/src/funcs/commerce/customerUsersUpdate.ts

@@ -0,0 +1,164 @@
+/*
+ * Update customer user.
+ */
+
+import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
+import { encodeJSON } 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 { APICall, APIPromise } from "../../types/async.js";
+import { Result } from "../../types/fp.js";
+
+export function customerUsersUpdate(
+  client: ClientSDK,
+  request: operations.UpdateCustomerUserRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.UpdateCustomerUserResponse,
+    | 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.UpdateCustomerUserRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.UpdateCustomerUserResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.UpdateCustomerUserRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.data, { explode: true });
+
+  const path = `/commerce/customers/${payload.customerId}/users/${payload.userId}`;
+  const headers = new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/hal+json",
+  });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "customer.users.update",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["5xx"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PATCH",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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: ["400", "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.UpdateCustomerUserResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.UpdateCustomerUserResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/funcs/commerce/index.ts

@@ -35,4 +35,19 @@ export * from "./reviewsCreate.js";
 export * from "./reviewsUpdate.js";
 export * from "./currenciesList.js";
 export * from "./currenciesGet.js";
-
+export * from "./customerUsersList.js";
+export * from "./customerUsersGet.js";
+export * from "./customerUsersUpdate.js";
+export * from "./customerUsersDelete.js";
+export * from "./customerUserInvitationsList.js";
+export * from "./customerUserInvitationsCreate.js";
+export * from "./customerUserInvitationsGet.js";
+export * from "./customerUserInvitationsRevoke.js";
+export * from "./customerUserInvitationsInspect.js";
+export * from "./customerUserInvitationsAccept.js";
+export * from "./customerUserRolesList.js";
+export * from "./customerUserRolesGet.js";
+export * from "./customerUserRolesCreate.js";
+export * from "./customerUserRolesUpdate.js";
+export * from "./customerUserRolesDelete.js";
+export * from "./customerUserPermissionsList.js";

package/src/funcs/users/index.ts

@@ -10,6 +10,7 @@ export * from "./usersUpdate.js";
 export * from "./usersSendPasswordResetLink.js";
 export * from "./usersResetPassword.js";
 export * from "./usersListCustomers.js";
+export * from "./usersGetCustomer.js";
 export * from "./usersListOAuthAccounts.js";
 export * from "./usersListMfaMethods.js";
 export * from "./usersGetMfaMethod.js";

package/src/funcs/users/usersGetCustomer.ts

@@ -0,0 +1,164 @@
+/*
+ * Get a user customer membership.
+ */
+
+import { encodeFormQuery } from "../../lib/encodings.js";
+import { ClientSDK, RequestOptions } from "../../lib/sdks.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 { APICall, APIPromise } from "../../types/async.js";
+import { Result } from "../../types/fp.js";
+
+export function usersGetCustomer(
+  client: ClientSDK,
+  request: operations.GetUserCustomerRequest,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    operations.GetUserCustomerResponse,
+    | 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.GetUserCustomerRequest,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      operations.GetUserCustomerResponse,
+      | errors.ErrorResponse
+      | errors.OminityDefaultError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) => operations.GetUserCustomerRequest$outboundSchema.parse(value),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = `/users/${payload.userId}/customers/${payload.customerId}`;
+  const query = encodeFormQuery({ include: payload.include });
+  const headers = new Headers({ Accept: "application/hal+json" });
+
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "users.customers.get",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 2,
+          maxElapsedTime: 7500,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["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: ["400", "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.GetUserCustomerResponse,
+    | errors.ErrorResponse
+    | errors.OminityDefaultError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(200, operations.GetUserCustomerResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.jsonErr("4XX", errors.ErrorResponse$inboundSchema, {
+      ctype: "application/hal+json",
+    }),
+    M.fail("5XX"),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}
+

package/src/funcs/users/usersListCustomers.ts

@@ -4,6 +4,7 @@
 
 import { ClientSDK, RequestOptions } from "../../lib/sdks.js";
 import {
+    encodeDeepObjectQuery,
     encodeSimple,
     encodeFormQuery,
     queryJoin,
@@ -92,11 +93,17 @@ async function $do(
     ) || "";
 
     const baseQuery = encodeFormQuery({
+        include: payload.include,
+        sort: payload.sort,
         page: payload.page,
         limit: payload.limit,
     });
 
-    const query = queryJoin(baseQuery);
+    const filterQuery = payload.filter != null
+        ? encodeDeepObjectQuery({ filter: payload.filter })
+        : undefined;
+
+    const query = queryJoin(baseQuery, filterQuery);
 
     const headers = new Headers({
         Accept: "application/hal+json",

package/src/lib/config.ts

@@ -75,7 +75,7 @@ function applyApiVersion(url: URL, apiVersion: string | undefined): URL {
   return url;
 }
 
-export const SDK_VERSION = "1.3.0";
+export const SDK_VERSION = "1.4.0";
 
 export const SDK_METADATA = {
   language: "typescript",

package/src/models/commerce/customer-user-invitation.ts

@@ -0,0 +1,94 @@
+/*
+ * Customer user invitation model.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { HalLinks, HalLinks$inboundSchema } from "../hal.js";
+
+export type CustomerUserInvitationStatus = "pending" | "accepted" | "revoked" | "expired";
+
+export type CustomerUserInvitationCustomer = {
+  resource: "customer";
+  id: number;
+  name: string;
+};
+
+export type CustomerUserInvitationRole = {
+  resource: "customer_user_role";
+  id: number;
+  key: string;
+  name: string;
+  description: string;
+};
+
+export type CustomerUserInvitation = {
+  resource: "customer_user_invitation";
+  id: number;
+  customerId: number;
+  roleId: number;
+  channelId: number | null;
+  userId: number | null;
+  email: string;
+  existingUser: boolean;
+  requiresAccountCreation: boolean;
+  status: CustomerUserInvitationStatus;
+  expiresAt: string;
+  acceptedAt: string | null;
+  revokedAt: string | null;
+  customer?: CustomerUserInvitationCustomer;
+  role?: CustomerUserInvitationRole;
+  updatedAt: string;
+  createdAt: string;
+  links?: HalLinks;
+};
+
+/** @internal */
+export const CustomerUserInvitation$inboundSchema: z.ZodType<CustomerUserInvitation> = z.object({
+  resource: z.literal("customer_user_invitation"),
+  id: z.number().int(),
+  customerId: z.number().int(),
+  roleId: z.number().int(),
+  channelId: z.number().int().nullable(),
+  userId: z.number().int().nullable(),
+  email: z.string(),
+  existingUser: z.boolean(),
+  requiresAccountCreation: z.boolean(),
+  status: z.enum(["pending", "accepted", "revoked", "expired"]),
+  expiresAt: z.string(),
+  acceptedAt: z.string().nullable(),
+  revokedAt: z.string().nullable(),
+  updatedAt: z.string(),
+  createdAt: z.string(),
+  _links: HalLinks$inboundSchema.optional(),
+  _embedded: z.object({
+    customer: z.object({
+      resource: z.literal("customer"),
+      id: z.number().int(),
+      name: z.string(),
+    }).loose().optional(),
+    role: z.object({
+      resource: z.literal("customer_user_role"),
+      id: z.number().int(),
+      key: z.string(),
+      name: z.string(),
+      description: z.string(),
+    }).loose().optional(),
+  }).loose().optional(),
+}).loose().transform((value) => {
+  const embedded = value._embedded;
+  const invitation = remap$(value, {
+    "_links": "links",
+    "_embedded": null,
+  }) as CustomerUserInvitation;
+
+  if (embedded?.customer) {
+    invitation.customer = embedded.customer;
+  }
+
+  if (embedded?.role) {
+    invitation.role = embedded.role;
+  }
+
+  return invitation;
+}) as unknown as z.ZodType<CustomerUserInvitation>;