@drttix/drt-sdk 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# DRT Public API
+
+A unified NPM package for typed API clients generated from OpenAPI specs.
+This package provides typed access to `shopper` and `scanner` services via `fetch`.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @drttix/public-api
+```
+
+---
+
+## 📦 Usage
+
+```ts
+import { DRT } from "@drttix/public-api";
+
+const shopperGuid = "your-shopper-guid";
+const account = "your-account";
+const apiKey = "your-api-key";
+
+const root = await DRT.shopper.account.getRoot(shopperGuid, account, apiKey);
+```
+
+---
+
+## 🛠️ Local Development (Developer Only)
+
+For SDK contributors testing against a local API server:
+
+```ts
+// Option 1: Use localhost:3000
+process.env.DRT_API_LOCAL = "true";
+
+// Option 2: Use a custom base URL
+process.env.DRT_API_BASE_URL = "http://localhost:8080";
+
+import { DRT } from "@drttix/public-api";
+```
+
+Or via command line:
+
+```bash
+# Use localhost:3000
+DRT_API_LOCAL=true npx tsx test.ts
+
+# Use custom base URL
+DRT_API_BASE_URL=http://localhost:8080 npx tsx test.ts
+```
+
+---

package/dist/cjs/index.d.ts

@@ -0,0 +1,20 @@
+export declare const DRT: {
+    shopper: {
+        account: typeof import("./src/generated/shopper").AccountService;
+        cart: typeof import("./src/generated/shopper").CartService;
+        code: typeof import("./src/generated/shopper").CodeService;
+        donation: typeof import("./src/generated/shopper").DonationService;
+        event: typeof import("./src/generated/shopper").EventService;
+        order: typeof import("./src/generated/shopper").OrderService;
+        payment: typeof import("./src/generated/shopper").PaymentService;
+        product: typeof import("./src/generated/shopper").ProductService;
+        seat: typeof import("./src/generated/shopper").SeatService;
+        session: typeof import("./src/generated/shopper").SessionService;
+    };
+    scanner: {
+        database: typeof import("./src/generated/scanner").DatabaseService;
+        orders: typeof import("./src/generated/scanner").OrdersService;
+        scanning: typeof import("./src/generated/scanner").ScanningService;
+    };
+};
+export type DRT = typeof DRT;

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+// AUTO-GENERATED FILE – DO NOT EDIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRT = void 0;
+const shopper_1 = require("./src/definitions/shopper");
+const scanner_1 = require("./src/definitions/scanner");
+const setBaseURL_1 = require("./src/functions/setBaseURL");
+exports.DRT = {
+    shopper: shopper_1.shopper,
+    scanner: scanner_1.scanner,
+};
+(0, setBaseURL_1.setBaseUrlsOnce)();

package/dist/cjs/src/definitions/scanner.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseService } from "../generated/scanner";
+import { OrdersService } from "../generated/scanner";
+import { ScanningService } from "../generated/scanner";
+export declare const scanner: {
+    database: typeof DatabaseService;
+    orders: typeof OrdersService;
+    scanning: typeof ScanningService;
+};

package/dist/cjs/src/definitions/scanner.js

@@ -0,0 +1,12 @@
+"use strict";
+// AUTO-GENERATED FILE – DO NOT EDIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanner = void 0;
+const scanner_1 = require("../generated/scanner");
+const scanner_2 = require("../generated/scanner");
+const scanner_3 = require("../generated/scanner");
+exports.scanner = {
+    database: scanner_1.DatabaseService,
+    orders: scanner_2.OrdersService,
+    scanning: scanner_3.ScanningService,
+};

package/dist/cjs/src/definitions/shopper.d.ts

@@ -0,0 +1,22 @@
+import { AccountService } from "../generated/shopper";
+import { CartService } from "../generated/shopper";
+import { CodeService } from "../generated/shopper";
+import { DonationService } from "../generated/shopper";
+import { EventService } from "../generated/shopper";
+import { OrderService } from "../generated/shopper";
+import { PaymentService } from "../generated/shopper";
+import { ProductService } from "../generated/shopper";
+import { SeatService } from "../generated/shopper";
+import { SessionService } from "../generated/shopper";
+export declare const shopper: {
+    account: typeof AccountService;
+    cart: typeof CartService;
+    code: typeof CodeService;
+    donation: typeof DonationService;
+    event: typeof EventService;
+    order: typeof OrderService;
+    payment: typeof PaymentService;
+    product: typeof ProductService;
+    seat: typeof SeatService;
+    session: typeof SessionService;
+};

package/dist/cjs/src/definitions/shopper.js

@@ -0,0 +1,26 @@
+"use strict";
+// AUTO-GENERATED FILE – DO NOT EDIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shopper = void 0;
+const shopper_1 = require("../generated/shopper");
+const shopper_2 = require("../generated/shopper");
+const shopper_3 = require("../generated/shopper");
+const shopper_4 = require("../generated/shopper");
+const shopper_5 = require("../generated/shopper");
+const shopper_6 = require("../generated/shopper");
+const shopper_7 = require("../generated/shopper");
+const shopper_8 = require("../generated/shopper");
+const shopper_9 = require("../generated/shopper");
+const shopper_10 = require("../generated/shopper");
+exports.shopper = {
+    account: shopper_1.AccountService,
+    cart: shopper_2.CartService,
+    code: shopper_3.CodeService,
+    donation: shopper_4.DonationService,
+    event: shopper_5.EventService,
+    order: shopper_6.OrderService,
+    payment: shopper_7.PaymentService,
+    product: shopper_8.ProductService,
+    seat: shopper_9.SeatService,
+    session: shopper_10.SessionService,
+};

package/dist/cjs/src/functions/setBaseURL.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sets the base URLs for all API clients.
+ *
+ * By default, uses the public production API.
+ *
+ * For local development (developer only), set:
+ *   DRT_API_LOCAL=true        (uses localhost:3000 for both services)
+ *   DRT_API_BASE_URL=<url>    (uses custom base URL for both services)
+ */
+export declare function setBaseUrlsOnce(): void;

package/dist/cjs/src/functions/setBaseURL.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBaseUrlsOnce = setBaseUrlsOnce;
+// Centralized base URL initialization for all services
+const OpenAPI_1 = require("../generated/shopper/core/OpenAPI");
+const OpenAPI_2 = require("../generated/scanner/core/OpenAPI");
+// Public API endpoints (default)
+const PUBLIC_API = {
+    shopper: "https://api.drttix.com/shopper",
+    scanner: "https://api.drttix.com/scanner-v3",
+};
+// One-time base URL initialization guard
+let didSetBaseUrls = false;
+/**
+ * Sets the base URLs for all API clients.
+ *
+ * By default, uses the public production API.
+ *
+ * For local development (developer only), set:
+ *   DRT_API_LOCAL=true        (uses localhost:3000 for both services)
+ *   DRT_API_BASE_URL=<url>    (uses custom base URL for both services)
+ */
+function setBaseUrlsOnce() {
+    if (didSetBaseUrls)
+        return;
+    didSetBaseUrls = true;
+    const customBase = process.env.DRT_API_BASE_URL;
+    const useLocal = process.env.DRT_API_LOCAL === "true";
+    const base = customBase || (useLocal ? "http://localhost:3000" : null);
+    OpenAPI_1.OpenAPI.BASE = base ? `${base}/shopper` : PUBLIC_API.shopper;
+    OpenAPI_2.OpenAPI.BASE = base ? `${base}/scanner-v3` : PUBLIC_API.scanner;
+}

package/dist/cjs/src/generated/scanner/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/cjs/src/generated/scanner/core/ApiError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/cjs/src/generated/scanner/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/cjs/src/generated/scanner/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/generated/scanner/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/cjs/src/generated/scanner/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/generated/scanner/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/dist/cjs/src/generated/scanner/core/CancelablePromise.js

@@ -0,0 +1,116 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+            __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/cjs/src/generated/scanner/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/cjs/src/generated/scanner/core/OpenAPI.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = void 0;
+exports.OpenAPI = {
+    BASE: 'https://api.drttix.com/scanner-v3',
+    VERSION: '20251217.3',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/dist/cjs/src/generated/scanner/core/request.d.ts

@@ -0,0 +1,30 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
+export declare const isString: (value: any) => value is string;
+export declare const isStringWithValue: (value: any) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions) => Promise<Headers>;
+export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
+export declare const getResponseHeader: (response: Response, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: Response) => Promise<any>;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+export {};