@cdx-forge/di-typescript-sdk 0.1.0-beta.1

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @candescent/di-typescript-sdk — TypeScript Server SDK for Candescent Digital Insight
+ *
+ * @example
+ * ```ts
+ * import { CandescentClient, Environment } from "@candescent/di-typescript-sdk";
+ *
+ * const client = new CandescentClient({
+ *   clientId: "my-client-id",
+ *   clientSecret: "my-secret",
+ *   institutionId: "12345",
+ *   environment: Environment.Stage,
+ * });
+ *
+ * const accounts = await client.accounts.list({ hostUserId: "user-12345" });
+ * console.log(accounts);
+ * ```
+ */
+export { CandescentClient, Environment, type ClientConfig } from "./client.js";
+export { ClientCredentialsProvider, PasswordGrantProvider, StaticTokenProvider, TokenEndpoint, type TokenProvider, type AccessToken, } from "./auth.js";
+export { PageIterator, type Page, type PageRequest, type PageFetcher } from "./pagination.js";
+export { type Result, type Ok, type Err, ok, err, safe } from "./result.js";
+export { CandescentError, ApiError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, ConnectionError, RequestTimeoutError, } from "./errors.js";
+export { OPERATION_REGISTRY, getAllCategories, getCategory, findOperation, searchOperations, getTotalOperationCount, type ParamInfo, type OperationInfo, type CategoryInfo, } from "./registry.js";
+export { validateParams, validateUrlParams, getMutuallyExclusivePairs } from "./validate.js";
+export * from "../generated/src/models/index.js";

package/dist/src/index.js

@@ -0,0 +1,29 @@
+/**
+ * @candescent/di-typescript-sdk — TypeScript Server SDK for Candescent Digital Insight
+ *
+ * @example
+ * ```ts
+ * import { CandescentClient, Environment } from "@candescent/di-typescript-sdk";
+ *
+ * const client = new CandescentClient({
+ *   clientId: "my-client-id",
+ *   clientSecret: "my-secret",
+ *   institutionId: "12345",
+ *   environment: Environment.Stage,
+ * });
+ *
+ * const accounts = await client.accounts.list({ hostUserId: "user-12345" });
+ * console.log(accounts);
+ * ```
+ */
+export { CandescentClient, Environment } from "./client.js";
+export { ClientCredentialsProvider, PasswordGrantProvider, StaticTokenProvider, TokenEndpoint, } from "./auth.js";
+export { PageIterator } from "./pagination.js";
+export { ok, err, safe } from "./result.js";
+export { CandescentError, ApiError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, ConnectionError, RequestTimeoutError, } from "./errors.js";
+// Operation registry — structured metadata for every DI API operation
+export { OPERATION_REGISTRY, getAllCategories, getCategory, findOperation, searchOperations, getTotalOperationCount, } from "./registry.js";
+// Parameter validation utilities
+export { validateParams, validateUrlParams, getMutuallyExclusivePairs } from "./validate.js";
+// Re-export all generated models for convenient typed usage
+export * from "../generated/src/models/index.js";

package/dist/src/operations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Standalone functions — importable individually for tree-shaking.
+ *
+ * Each function creates a short-lived client from env vars and calls a
+ * single operation. Ideal for serverless or lightweight scripts.
+ *
+ * @example
+ * ```ts
+ * import { listAccounts } from "@candescent/di-typescript-sdk/operations";
+ * const accounts = await listAccounts();
+ * ```
+ */
+import type { AccountsResponse, Account, TransactionList } from "../generated/src/models/index.js";
+export declare function listAccounts(params?: {
+    hostUserId?: string;
+    loginId?: string;
+    page?: number;
+    size?: number;
+}): Promise<AccountsResponse>;
+export declare function getAccount(params: {
+    accountId: string;
+    hostUserId?: string;
+    loginId?: string;
+}): Promise<Account>;
+export declare function listTransactions(params: {
+    accountId: string;
+    hostUserId?: string;
+    loginId?: string;
+    page?: number;
+    size?: number;
+}): Promise<TransactionList>;

package/dist/src/operations.js

@@ -0,0 +1,45 @@
+/**
+ * Standalone functions — importable individually for tree-shaking.
+ *
+ * Each function creates a short-lived client from env vars and calls a
+ * single operation. Ideal for serverless or lightweight scripts.
+ *
+ * @example
+ * ```ts
+ * import { listAccounts } from "@candescent/di-typescript-sdk/operations";
+ * const accounts = await listAccounts();
+ * ```
+ */
+import { CandescentClient } from "./client.js";
+import { validateParams } from "./validate.js";
+export async function listAccounts(params) {
+    if (params)
+        validateParams(params);
+    const client = CandescentClient.fromEnv();
+    try {
+        return await client.accounts.list(params ?? {});
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function getAccount(params) {
+    validateParams(params);
+    const client = CandescentClient.fromEnv();
+    try {
+        return await client.accounts.get(params);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function listTransactions(params) {
+    validateParams(params);
+    const client = CandescentClient.fromEnv();
+    try {
+        return await client.accounts.listTransactions(params);
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/src/pagination.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Lazy, async-iterable pagination.
+ *
+ * Provides both async-iterator protocol and convenience helpers
+ * like .toArray(), .map(), .take().
+ */
+export interface Page<T> {
+    items: T[];
+    hasMore: boolean;
+    nextPageToken?: string;
+    totalElements?: number;
+}
+export interface PageRequest {
+    page?: number;
+    size?: number;
+    pageToken?: string;
+}
+export type PageFetcher<T> = (request: PageRequest) => Promise<Page<T>>;
+export declare class PageIterator<T> implements AsyncIterable<T> {
+    private static readonly MAX_PAGES;
+    private readonly fetcher;
+    private readonly initialRequest;
+    constructor(fetcher: PageFetcher<T>, initialRequest?: PageRequest);
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Collect all pages into a single array. */
+    toArray(): Promise<T[]>;
+    /** Return the first N items. */
+    take(n: number): Promise<T[]>;
+    /** Async map over all paginated results. */
+    map<U>(fn: (item: T) => U | Promise<U>): Promise<U[]>;
+}

package/dist/src/pagination.js

@@ -0,0 +1,67 @@
+/**
+ * Lazy, async-iterable pagination.
+ *
+ * Provides both async-iterator protocol and convenience helpers
+ * like .toArray(), .map(), .take().
+ */
+export class PageIterator {
+    static MAX_PAGES = 1000;
+    fetcher;
+    initialRequest;
+    constructor(fetcher, initialRequest = { page: 0, size: 25 }) {
+        this.fetcher = fetcher;
+        this.initialRequest = initialRequest;
+    }
+    async *[Symbol.asyncIterator]() {
+        let request = { ...this.initialRequest };
+        let hasMore = true;
+        let pageCount = 0;
+        let prevToken;
+        while (hasMore) {
+            if (++pageCount > PageIterator.MAX_PAGES) {
+                throw new Error(`PageIterator: exceeded ${PageIterator.MAX_PAGES} pages — possible infinite loop`);
+            }
+            const page = await this.fetcher(request);
+            const items = page.items ?? [];
+            for (const item of items)
+                yield item;
+            hasMore = page.hasMore;
+            if (hasMore) {
+                if (page.nextPageToken) {
+                    if (page.nextPageToken === prevToken) {
+                        throw new Error("PageIterator: nextPageToken did not change — aborting to prevent infinite loop");
+                    }
+                    prevToken = page.nextPageToken;
+                    request = { ...request, pageToken: page.nextPageToken };
+                }
+                else {
+                    request = { ...request, page: (request.page ?? 0) + 1 };
+                }
+            }
+        }
+    }
+    /** Collect all pages into a single array. */
+    async toArray() {
+        const items = [];
+        for await (const item of this)
+            items.push(item);
+        return items;
+    }
+    /** Return the first N items. */
+    async take(n) {
+        const items = [];
+        for await (const item of this) {
+            items.push(item);
+            if (items.length >= n)
+                break;
+        }
+        return items;
+    }
+    /** Async map over all paginated results. */
+    async map(fn) {
+        const results = [];
+        for await (const item of this)
+            results.push(await fn(item));
+        return results;
+    }
+}

package/dist/src/registry.d.ts

@@ -0,0 +1,69 @@
+export interface ParamInfo {
+    name: string;
+    in: string;
+    required: boolean;
+    conditionallyRequired: boolean;
+    conditionalReason: string | null;
+    mutuallyExclusiveWith: string[] | null;
+    type: string;
+    description: string;
+    default?: string;
+    enum?: string[];
+    format?: string;
+}
+export interface OperationInfo {
+    operationId: string;
+    tagGroup: string;
+    tag: string;
+    /** @deprecated Use `tag` — kept for backward compatibility */
+    category: string;
+    methodName: string;
+    httpMethod: string;
+    path: string;
+    summary: string;
+    params: ParamInfo[];
+    bodySchema: {
+        ref?: string;
+        type?: string;
+    } | null;
+    sdkAccessor: string;
+    sdkMethod: string;
+}
+export interface TagInfo {
+    name: string;
+    displayName: string;
+    tagGroup: string;
+}
+export interface TagGroupInfo {
+    name: string;
+    displayName: string;
+    tags: string[];
+}
+/** @deprecated Use TagInfo */
+export type CategoryInfo = TagInfo;
+declare const TAG_GROUPS: Record<string, TagGroupInfo>;
+declare const TAGS: Record<string, TagInfo>;
+declare const OPERATIONS: Record<string, OperationInfo>;
+export { OPERATIONS as OPERATION_REGISTRY };
+export { TAGS, TAG_GROUPS };
+/** @deprecated Use TAGS */
+export declare const CATEGORIES: Record<string, TagInfo>;
+export declare function getAllTagGroups(): Array<TagGroupInfo & {
+    tagInfos: Array<TagInfo & {
+        operations: OperationInfo[];
+    }>;
+}>;
+export declare function getAllCategories(): Array<TagInfo & {
+    operations: OperationInfo[];
+}>;
+export declare function getCategory(name: string): (TagInfo & {
+    operations: OperationInfo[];
+}) | undefined;
+export declare function getTagGroup(name: string): (TagGroupInfo & {
+    tagInfos: Array<TagInfo & {
+        operations: OperationInfo[];
+    }>;
+}) | undefined;
+export declare function findOperation(nameOrId: string): OperationInfo | undefined;
+export declare function searchOperations(query: string): OperationInfo[];
+export declare function getTotalOperationCount(): number;