@seliseblocks/client 0.1.0-beta.0

package/dist/data/types.d.ts

@@ -0,0 +1,148 @@
+export type BlocksPagedResult<T> = {
+    data?: {
+        items?: T[];
+        totalCount?: number;
+    };
+    errors?: unknown;
+    httpStatusCode?: number;
+    isSuccess?: boolean;
+    message?: string | null;
+};
+export type BlocksDataListOptions = {
+    pageNo?: number;
+    pageSize?: number;
+    query?: Record<string, boolean | number | string | undefined>;
+};
+export type BlocksDataCollection<T = Record<string, unknown>> = {
+    create(payload: Partial<T>): Promise<unknown>;
+    delete(itemId: string): Promise<unknown>;
+    get(itemId: string): Promise<unknown>;
+    list(options?: BlocksDataListOptions): Promise<unknown>;
+    update(itemId: string, payload: Partial<T>): Promise<unknown>;
+};
+export type BlocksDataSchema = Record<string, unknown> & {
+    schemaName?: string;
+};
+export type BlocksSchemaListOptions = {
+    collectionName?: string;
+    keyword?: string;
+    pageNo?: number;
+    pageSize?: number;
+    schemaName?: string;
+    schemaType?: number;
+    sortBy?: string;
+    sortDescending?: boolean;
+};
+export type BlocksSchemaValidationListOptions = BlocksSchemaListOptions & {
+    fieldName?: string;
+    schemaId?: string;
+};
+export type BlocksSchemaFieldValidationOptions = {
+    fieldName: string;
+    schemaId: string;
+};
+export type BlocksRegexGenerateRequest = Record<string, unknown> & {
+    description: string;
+};
+export type BlocksGraphqlRequest = {
+    headers?: HeadersInit;
+    operationName?: string;
+    query: string;
+    variables?: Record<string, unknown>;
+};
+export type BlocksFileUploadRequest = Record<string, unknown> & {
+    accessModifier?: string;
+    additionalProperties?: Record<string, string>;
+    configurationName?: string;
+    contentType?: string;
+    fileName?: string;
+    itemId?: string;
+    metaData?: string;
+    moduleName?: number | string;
+    name?: string;
+    parentDirectoryId?: string;
+    tags?: string;
+};
+export type BlocksFileListRequest = Record<string, unknown> & {
+    configurationName?: string;
+    fileIds?: string[];
+};
+export type BlocksFileInfoListRequest = Record<string, unknown> & {
+    filter?: Record<string, unknown>;
+    page?: number;
+    pageNo?: number;
+    pageSize?: number;
+    sort?: {
+        isDescending?: boolean;
+        property?: string;
+    };
+};
+export type BlocksFileGetOptions = {
+    configurationName?: string;
+    version?: number;
+};
+export type BlocksFileDeleteRequest = Record<string, unknown> & {
+    configurationName?: string;
+    eventQueueName?: string;
+    fileId: string;
+};
+export type BlocksFolderDeleteRequest = Record<string, unknown> & {
+    configurationName?: string;
+    folderId: string;
+};
+export type BlocksFileUpdateAdditionalInfoRequest = Record<string, unknown> & {
+    additionalProperties?: Record<string, string>;
+    itemId: string;
+};
+export type BlocksLocalStorageUploadRequest = Record<string, unknown> & {
+    accessModifier?: string;
+    additionalProperties?: Record<string, string>;
+    configurationName?: string;
+    file: Blob;
+    itemId?: string;
+    metaData?: string;
+    name: string;
+    parentDirectoryId?: string;
+    tags?: string | string[];
+};
+export type BlocksUploadToUrlRequest = {
+    body: Blob | ArrayBuffer | ArrayBufferView | ReadableStream;
+    contentType?: string;
+    headers?: HeadersInit;
+    url: string;
+};
+export type BlocksDmsListRequest = Record<string, unknown> & {
+    configurationName?: string;
+    moduleName?: string;
+    parentId?: string;
+    searchKey?: string;
+    skip?: number;
+    take?: number;
+};
+export type BlocksDmsMetaDataValue = {
+    type: string;
+    value: string;
+};
+export type BlocksDmsUploadItem = Record<string, unknown> & {
+    artifactName?: string;
+    configurationName?: string;
+    description?: string;
+    fileStorageId: string;
+    metaData?: Record<string, BlocksDmsMetaDataValue>;
+    organizationId?: string;
+    parentId?: string;
+    tags?: string[];
+};
+export type BlocksDmsUploadRequest = Record<string, unknown> & {
+    upload: BlocksDmsUploadItem[];
+};
+export type BlocksDmsCreateFolderRequest = Record<string, unknown> & {
+    artifactName: string;
+    configurationName?: string;
+    description?: string;
+    fileStorageId?: string;
+    metaData?: Record<string, BlocksDmsMetaDataValue>;
+    organizationId?: string;
+    parentId?: string;
+    tags?: string[];
+};

package/dist/data/types.js

@@ -0,0 +1 @@
+export {};

package/dist/http/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class BlocksApiError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: unknown;
+    constructor(status: number, statusText: string, body: unknown);
+}

package/dist/http/errors.js

@@ -0,0 +1,23 @@
+export class BlocksApiError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(status, statusText, body) {
+        super(buildMessage(status, statusText, body));
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "BlocksApiError";
+    }
+}
+function buildMessage(status, statusText, body) {
+    if (typeof body === "object" && body) {
+        const record = body;
+        const message = record.message ?? record.detail ?? record.error_description ?? record.error;
+        if (typeof message === "string" && message)
+            return `Blocks API ${status} ${statusText}: ${message}`;
+    }
+    if (typeof body === "string" && body)
+        return `Blocks API ${status} ${statusText}: ${body}`;
+    return `Blocks API ${status} ${statusText}`;
+}

package/dist/http/http-client.d.ts

@@ -0,0 +1,11 @@
+import { BlocksAuthenticationClient } from "../auth/auth-client.js";
+import { RequiredConfig } from "../client.js";
+import { BlocksExternalRequestOptions, BlocksRequestOptions } from "../types.js";
+export declare class BlocksHttpClient {
+    private readonly config;
+    private readonly auth;
+    private readonly fetchImpl;
+    constructor(config: RequiredConfig, auth: BlocksAuthenticationClient, fetchImpl?: typeof fetch);
+    request<T>(path: string, options?: BlocksRequestOptions): Promise<T>;
+    external<T = unknown>(url: string, options?: BlocksExternalRequestOptions): Promise<T>;
+}

package/dist/http/http-client.js

@@ -0,0 +1,82 @@
+import { BlocksApiError } from "./errors.js";
+export class BlocksHttpClient {
+    config;
+    auth;
+    fetchImpl;
+    constructor(config, auth, fetchImpl = globalThis.fetch) {
+        this.config = config;
+        this.auth = auth;
+        this.fetchImpl = fetchImpl;
+        if (!this.fetchImpl)
+            throw new Error("Blocks client requires fetch.");
+    }
+    async request(path, options = {}) {
+        const url = buildUrl(this.config.apiUrl, path, options.query);
+        const headers = new Headers(options.headers);
+        const rawBody = isBodyInit(options.body) ? options.body : undefined;
+        headers.set("Accept", "application/json");
+        headers.set("x-blocks-key", this.config.xBlocksKey);
+        if (options.body !== undefined && !rawBody && !headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+        }
+        if (options.auth !== false) {
+            const token = options.accessToken ?? await this.auth.accessToken();
+            if (token)
+                headers.set("Authorization", `Bearer ${token}`);
+        }
+        const response = await this.fetchImpl(url, {
+            body: rawBody ?? (options.body === undefined ? undefined : JSON.stringify(options.body)),
+            headers,
+            method: options.method ?? (options.body === undefined ? "GET" : "POST")
+        });
+        const body = await parseBody(response);
+        if (!response.ok)
+            throw new BlocksApiError(response.status, response.statusText, body);
+        return body;
+    }
+    async external(url, options = {}) {
+        const response = await this.fetchImpl(url, {
+            body: options.body,
+            headers: options.headers,
+            method: options.method ?? "GET"
+        });
+        const body = await parseBody(response);
+        if (!response.ok)
+            throw new BlocksApiError(response.status, response.statusText, body);
+        return body;
+    }
+}
+function isBodyInit(value) {
+    return typeof Blob !== "undefined" && value instanceof Blob
+        || typeof FormData !== "undefined" && value instanceof FormData
+        || typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams
+        || typeof ReadableStream !== "undefined" && value instanceof ReadableStream
+        || value instanceof ArrayBuffer
+        || ArrayBuffer.isView(value);
+}
+function buildUrl(baseUrl, path, query) {
+    const url = /^https?:\/\//i.test(path)
+        ? new URL(path)
+        : new URL(path.replace(/^\/+/, ""), `${baseUrl}/`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+}
+async function parseBody(response) {
+    if (response.status === 204)
+        return undefined;
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json"))
+        return JSON.parse(text);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/iam/iam-client.d.ts

@@ -0,0 +1,226 @@
+import { BlocksHttpClient } from "../http/http-client.js";
+import { BlocksBaseResponse, BlocksGetMyOrganizationsResponse, BlocksGetOrganizationResponse, BlocksGetOrganizationsResponse, BlocksGetPermissionResponse, BlocksGetPermissionsResponse, BlocksGetRoleResponse, BlocksGetRolesResponse, BlocksGetUserResponse, BlocksGetUsersResponse, BlocksIamListRequest, BlocksMeResponse } from "./types.js";
+export declare class BlocksIAMClient {
+    private readonly http;
+    constructor(http: BlocksHttpClient);
+    /**
+     * Current authenticated IAM account from `GET /iam/v4/iam/me`.
+     * Use this for app profile bootstrapping because it returns the Blocks user record,
+     * roles, permissions, and active organization context according to the access token.
+     */
+    me(): Promise<BlocksMeResponse>;
+    /**
+     * Updates the current authenticated user's IAM profile through `POST /iam/v4/iam/me`.
+     * The backend resolves the user id from the token; callers must not send another user's id.
+     */
+    updateMe(request: Record<string, unknown>): Promise<BlocksBaseResponse>;
+    users: {
+        /**
+         * What: creates a user through `POST /iam/v4/iam/users/create`.
+         * Why: authorized admin UIs need to invite/provision users in the active tenant/organization.
+         * How: pass IAM's create-user payload; caller permissions determine whether the API accepts it.
+         */
+        create: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: updates a user through `POST /iam/v4/iam/users/{id}`.
+         * Why: authorized admin UIs need to edit IAM profile fields.
+         * How: pass the user id in the route and IAM's update payload in the body.
+         */
+        update: (id: string, request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: deactivates a user through `POST /iam/v4/iam/users/deactivate`.
+         * Why: admin UIs need to remove access without deleting the user record.
+         * How: pass IAM's deactivate payload for the target user.
+         */
+        deactivate: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: activates a user through `POST /iam/v4/iam/users/activate`.
+         * Why: admin UIs need to restore access for a previously inactive account.
+         * How: pass IAM's activate payload for the target user.
+         */
+        activate: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: queries users through `POST /iam/v4/iam/users`.
+         * Why: IAM uses a POST-read contract for paging/filtering user lists.
+         * How: pass `pageNo`, `pageSize`, search/filter fields, or the exact IAM list payload your UI needs.
+         */
+        list: (request?: BlocksIamListRequest) => Promise<BlocksGetUsersResponse>;
+        /**
+         * What: reads one user through `GET /iam/v4/iam/users/{id}`.
+         * Why: user detail screens need one IAM user record, optionally for a specific organization context.
+         * How: pass the user id and optional `organizationId`.
+         */
+        get: (id: string, options?: {
+            organizationId?: string;
+        }) => Promise<BlocksGetUserResponse>;
+        /**
+         * What: updates user access through `POST /iam/v4/iam/users/access`.
+         * Why: admin UIs need to grant or change roles/permissions for a user.
+         * How: pass IAM's access payload; the active token and tenant header define allowed scope.
+         */
+        updateAccess: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: revokes user access through `POST /iam/v4/iam/users/revoke-access`.
+         * Why: admin UIs need to remove roles/permissions or organization access.
+         * How: pass IAM's revoke-access payload.
+         */
+        revokeAccess: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: checks email availability through `GET /iam/v4/iam/email/available`.
+         * Why: signup and invite forms can validate duplicate email state before submit.
+         * How: pass the email query fields IAM expects; this is public but still sends `x-blocks-key`.
+         */
+        emailAvailable: (query: Record<string, string | undefined>) => Promise<{
+            isAvailable?: boolean;
+            IsAvailable?: boolean;
+        }>;
+        /**
+         * What: checks whether a user exists through `GET /iam/v4/iam/users/exists`.
+         * Why: account and invite flows may need an existence check by email.
+         * How: pass the email string; the SDK sends it as the `email` query parameter.
+         */
+        exists: (email: string) => Promise<unknown>;
+    };
+    permissions: {
+        /**
+         * What: creates a permission through `POST /iam/v4/iam/permissions/create`.
+         * Why: authorized admin tooling may manage custom IAM permission definitions.
+         * How: pass IAM's create-permission payload.
+         */
+        create: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: updates a permission through `POST /iam/v4/iam/permissions/{id}`.
+         * Why: admin tooling may need to edit permission metadata.
+         * How: pass the permission id and IAM's update payload.
+         */
+        update: (id: string, request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: queries permissions through `POST /iam/v4/iam/permissions`.
+         * Why: IAM uses a POST-read contract for permission paging/filtering.
+         * How: pass `pageNo`, `pageSize`, search/filter fields, or IAM's exact list payload.
+         */
+        list: (request?: BlocksIamListRequest) => Promise<BlocksGetPermissionsResponse>;
+        /**
+         * What: groups permissions by severity through `GET /iam/v4/iam/permissions/by-severity`.
+         * Why: role/access UIs often display permissions grouped by risk or category.
+         * How: call after an authorized token is available.
+         */
+        bySeverity: () => Promise<unknown[]>;
+        /**
+         * What: reads one permission through `GET /iam/v4/iam/permissions/{id}`.
+         * Why: admin detail/edit screens need one permission record.
+         * How: pass the permission id from IAM.
+         */
+        get: (id: string) => Promise<BlocksGetPermissionResponse>;
+    };
+    roles: {
+        /**
+         * What: creates a role through `POST /iam/v4/iam/roles/create`.
+         * Why: admin UIs need to define permission bundles users can be assigned to.
+         * How: pass IAM's create-role payload.
+         */
+        create: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: updates a role through `POST /iam/v4/iam/roles/update`.
+         * Why: admin UIs need to edit role names, metadata, or other IAM-supported fields.
+         * How: pass IAM's role update payload.
+         */
+        update: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: queries roles through `POST /iam/v4/iam/roles`.
+         * Why: IAM uses a POST-read contract for role paging/filtering.
+         * How: pass `pageNo`, `pageSize`, search/filter fields, or IAM's exact list payload.
+         */
+        list: (request?: BlocksIamListRequest) => Promise<BlocksGetRolesResponse>;
+        /**
+         * What: reads one role through `GET /iam/v4/iam/roles/{id}`.
+         * Why: role detail/edit screens need one IAM role record.
+         * How: pass the role id from IAM.
+         */
+        get: (id: string) => Promise<BlocksGetRoleResponse>;
+        /**
+         * What: assigns permissions to a role through `POST /iam/v4/iam/roles/assign-permissions`.
+         * Why: role editors need to attach or replace permission sets.
+         * How: pass IAM's assign-permissions payload.
+         */
+        assignPermissions: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: lists assignable roles through `GET /iam/v4/iam/roles/assignable`.
+         * Why: user-access UIs should only show roles the current user can assign.
+         * How: call after an authorized token is available.
+         */
+        assignable: () => Promise<unknown>;
+    };
+    resources: {
+        /**
+         * What: lists resource groups through `GET /iam/v4/iam/resource-groups`.
+         * Why: permission screens need resource grouping metadata for navigation and display.
+         * How: call after an authorized token is available.
+         */
+        groups: () => Promise<unknown[]>;
+        /**
+         * What: lists feature/resource flags through `GET /iam/v4/iam/resource/features`.
+         * Why: frontends use this to feature-gate UI based on current roles and permissions.
+         * How: pass optional query fields supported by IAM; the active token defines the user context.
+         */
+        features: (query?: Record<string, string | number | boolean | undefined>) => Promise<unknown[]>;
+    };
+    organizations: {
+        /**
+         * What: creates an organization through `POST /iam/v4/iam/organizations/create`.
+         * Why: authorized admin UIs may need tenant organization management.
+         * How: pass IAM's create-organization payload.
+         */
+        create: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: updates an organization through `POST /iam/v4/iam/organizations/{id}`.
+         * Why: organization settings screens need to edit metadata/config.
+         * How: pass the organization id and IAM's update payload.
+         */
+        update: (id: string, request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+        /**
+         * What: lists organizations through `GET /iam/v4/iam/organizations`.
+         * Why: admin UIs need organization browsing and selection.
+         * How: pass IAM-supported query fields such as paging/search options.
+         */
+        list: (query?: Record<string, string | number | boolean | undefined>) => Promise<BlocksGetOrganizationsResponse>;
+        /**
+         * What: reads one organization through `GET /iam/v4/iam/organizations/{id}`.
+         * Why: organization detail screens need one organization record.
+         * How: pass the organization id from IAM.
+         */
+        get: (id: string) => Promise<BlocksGetOrganizationResponse>;
+        /**
+         * What: lists current-user organizations through `GET /iam/v4/iam/organizations/my`.
+         * Why: apps need available organizations for org switchers and context selectors.
+         * How: call with the current user's access token.
+         */
+        my: () => Promise<BlocksGetMyOrganizationsResponse>;
+        /**
+         * What: reads organization configuration through `GET /iam/v4/iam/organizations/config`.
+         * Why: settings screens need the active organization's current configuration.
+         * How: call with an authorized token in the desired organization context.
+         */
+        getConfig: () => Promise<Record<string, unknown>>;
+        /**
+         * What: saves organization configuration through `POST /iam/v4/iam/organizations/config`.
+         * Why: settings screens need to persist organization-level behavior.
+         * How: pass IAM's organization config payload.
+         */
+        saveConfig: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+    };
+    signupSettings: {
+        /**
+         * What: reads signup settings through `GET /iam/v4/iam/signup-settings`.
+         * Why: public signup screens need tenant policy before a user is authenticated.
+         * How: call without an access token; the SDK still sends `x-blocks-key`.
+         */
+        get: () => Promise<Record<string, unknown>>;
+        /**
+         * What: saves signup settings through `POST /iam/v4/iam/signup-settings`.
+         * Why: admin/settings screens need to configure signup policy.
+         * How: pass IAM's signup-settings payload with an authorized token.
+         */
+        save: (request: Record<string, unknown>) => Promise<BlocksBaseResponse>;
+    };
+}