@omnibase/core-js 0.5.9 → 0.6.0

package/dist/payments/index.d.ts

@@ -1068,6 +1068,117 @@ declare class PaymentHandler {
     readonly usage: UsageManager;
 }
 
+interface UploadOptions {
+    /**
+     * Custom metadata to attach to the file
+     * This will be stored in the JSONB metadata column
+     */
+    metadata?: Record<string, any>;
+}
+interface UploadResult {
+    /**
+     * Pre-signed URL for uploading the file
+     */
+    upload_url: string;
+    /**
+     * Full path where the file is stored
+     */
+    path: string;
+}
+interface DownloadResult {
+    /**
+     * Pre-signed URL for downloading the file
+     */
+    download_url: string;
+}
+/**
+ * Storage client for file operations with path-based organization
+ *
+ * Users control the full file path and define RLS policies based on path patterns.
+ * Common patterns:
+ * - `public/*` - Public files
+ * - `users/{user_id}/*` - User private files
+ * - `teams/{team_id}/*` - Team shared files
+ *
+ * @example
+ * ```typescript
+ * const storage = omnibase.storage();
+ *
+ * // Upload to public directory
+ * await storage.upload('public/images/avatar.png', file);
+ *
+ * // Upload to user private directory
+ * await storage.upload('users/123/documents/report.pdf', file, {
+ *   metadata: {
+ *     department: 'engineering',
+ *     confidential: true
+ *   }
+ * });
+ *
+ * // Download file
+ * const { download_url } = await storage.download('public/images/avatar.png');
+ *
+ * // Delete file
+ * await storage.delete('users/123/documents/report.pdf');
+ * ```
+ */
+declare class StorageClient {
+    private client;
+    constructor(client: OmnibaseClient);
+    /**
+     * Upload a file to storage
+     *
+     * @param path - Full path for the file (e.g., "public/images/avatar.png", "users/123/private/doc.pdf")
+     * @param file - File or Blob to upload
+     * @param options - Upload options including custom metadata
+     *
+     * @example
+     * ```typescript
+     * const result = await storage.upload(
+     *   'public/avatars/user-123.png',
+     *   file,
+     *   {
+     *     metadata: {
+     *       userId: '123',
+     *       uploadedBy: 'john@example.com',
+     *       tags: ['profile', 'avatar']
+     *     }
+     *   }
+     * );
+     *
+     * // File is automatically uploaded to S3 via the presigned URL
+     * console.log('File uploaded to:', result.path);
+     * ```
+     */
+    upload(path: string, file: File | Blob, options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Download a file from storage
+     *
+     * @param path - Full path to the file
+     *
+     * @example
+     * ```typescript
+     * const { download_url } = await storage.download('public/images/logo.png');
+     *
+     * // Download the file
+     * const response = await fetch(download_url);
+     * const blob = await response.blob();
+     * ```
+     */
+    download(path: string): Promise<DownloadResult>;
+    /**
+     * Delete a file from storage
+     *
+     * @param path - Full path to the file
+     *
+     * @example
+     * ```typescript
+     * await storage.delete('users/123/documents/old-report.pdf');
+     * ```
+     */
+    delete(path: string): Promise<void>;
+}
+
 /**
  * Request data for accepting a tenant invitation
  *
@@ -1226,6 +1337,8 @@ type CreateTenantUserInviteRequest = {
     email: string;
     /** Role the invited user will have in the tenant */
     role: string;
+    /** Invite URL - the link that will be sent to the users email suffixed automatically w/ ?token=XYZ */
+    invite_url: string;
 };
 /**
  * Tenant invitation management handler
@@ -1401,7 +1514,7 @@ declare class TenantInviteManager {
      * @public
      * @group User Management
      */
-    create(tenantId: string, inviteData: CreateTenantUserInviteRequest): Promise<CreateTenantUserInviteResponse>;
+    create(inviteData: CreateTenantUserInviteRequest): Promise<CreateTenantUserInviteResponse>;
 }
 
 /**
@@ -1645,10 +1758,6 @@ declare class TenantManger {
      *   billing_email: 'billing@acme.com',
      *   user_id: 'user_123'
      * });
-     *
-     * console.log(`Created tenant: ${newTenant.data.tenant.name}`);
-     * // Store the token for authenticated requests
-     * localStorage.setItem('tenant_token', newTenant.data.token);
      * ```
      *
      *
@@ -1796,6 +1905,195 @@ declare class TenantManger {
     switchActiveTenant(tenantId: string): Promise<SwitchActiveTenantResponse>;
 }
 
+/**
+ * Request parameters for updating a user's role within a tenant
+ *
+ * This interface defines the data required to change a user's role in the active tenant.
+ * The operation requires appropriate permissions (typically admin or owner role) and will
+ * fail if the requesting user doesn't have sufficient privileges.
+ *
+ * @example
+ * ```typescript
+ * const request: UpdateTenantUserRoleRequest = {
+ *   user_id: 'user_abc123',
+ *   role: 'admin'
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @public
+ * @group Tenant User Management
+ */
+type UpdateTenantUserRoleRequest = {
+    /** New role to assign to the user (e.g., 'admin', 'member', 'viewer') */
+    role: string;
+    /** ID of the user whose role is being updated */
+    user_id: string;
+};
+/**
+ * Response from updating a user's role within a tenant
+ *
+ * This type represents the API response structure returned after successfully
+ * updating a user's role in the tenant.
+ *
+ * @since 1.0.0
+ * @public
+ * @group Tenant User Management
+ */
+type UpdateTenantUserRoleResponse = ApiResponse<{
+    /** Confirmation message describing the role update */
+    message: string;
+}>;
+/**
+ * Request parameters for removing a user from a tenant
+ *
+ * This interface defines the data required to remove a user from the active tenant.
+ * The operation requires appropriate permissions and will fail if the user doesn't
+ * have the necessary rights to remove users from the tenant.
+ *
+ * @example
+ * ```typescript
+ * const request: RemoveUserRequest = {
+ *   user_id: 'user_abc123'
+ * };
+ * ```
+ *
+ * @since 1.0.0
+ * @public
+ * @group Tenant User Management
+ */
+type RemoveUserRequest = {
+    /** ID of the user being removed from the tenant */
+    user_id: string;
+};
+/**
+ * Manager for tenant user operations
+ *
+ * This class provides methods for managing users within a tenant, including
+ * removing users from the active tenant. All operations are performed within
+ * the context of the authenticated user and respect tenant-level permissions.
+ *
+ * User removal operations require appropriate permissions (typically admin or owner
+ * role) and will fail if the requesting user doesn't have sufficient privileges.
+ *
+ * @example
+ * ```typescript
+ * import { OmnibaseClient } from '@omnibase/core-js';
+ *
+ * const client = new OmnibaseClient({ apiKey: 'your-api-key' });
+ * const userManager = client.tenants.user;
+ *
+ * // Remove a user from the active tenant
+ * await userManager.remove({ user_id: 'user_123' });
+ * ```
+ *
+ * @since 1.0.0
+ * @public
+ * @group Tenant User Management
+ */
+declare class TenantUserManager {
+    private omnibaseClient;
+    /**
+     * Creates a new tenant user manager
+     *
+     * @param omnibaseClient - Configured OmnibaseClient instance for API communication
+     *
+     * @group Tenant User Management
+     */
+    constructor(omnibaseClient: OmnibaseClient);
+    /**
+     * Removes a user from the active tenant
+     *
+     * This method removes a specified user from the current active tenant. The operation
+     * requires the requesting user to have appropriate permissions (admin or owner role).
+     * The user being removed will lose access to the tenant and all its resources.
+     *
+     * Note: You cannot remove yourself from a tenant using this method. To leave a tenant,
+     * use the appropriate leave or delete tenant operations instead.
+     *
+     * @param data - Request data containing the user ID to remove
+     * @param data.user_id - ID of the user to remove from the tenant
+     *
+     * @returns Promise resolving to an API response confirming the removal
+     *
+     * @throws {Error} When user_id is not provided
+     * @throws {Error} When the API request fails (includes status code and error details)
+     * @throws {Error} When the user doesn't have permission to remove users
+     * @throws {Error} When the specified user is not a member of the tenant
+     *
+     * @example
+     * ```typescript
+     * // Remove a user from the active tenant
+     * try {
+     *   await userManager.remove({ user_id: 'user_abc123' });
+     *   console.log('User removed successfully');
+     * } catch (error) {
+     *   if (error.message.includes('403')) {
+     *     console.error('Insufficient permissions to remove user');
+     *   } else if (error.message.includes('404')) {
+     *     console.error('User not found in tenant');
+     *   } else {
+     *     console.error('Failed to remove user:', error);
+     *   }
+     * }
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     * @group Tenant User Management
+     */
+    remove(data: RemoveUserRequest): Promise<ApiResponse<"">>;
+    /**
+     * Updates a user's role within the active tenant
+     *
+     * This method changes the role of a specified user in the current active tenant. The operation
+     * requires the requesting user to have appropriate permissions (typically admin or owner role).
+     * Role updates take effect immediately and affect the user's permissions and access rights
+     * within the tenant.
+     *
+     * Common roles include 'admin', 'member', and 'viewer', but the exact roles available depend
+     * on your tenant's configuration. Changing a user's role will modify their ability to perform
+     * various operations within the tenant.
+     *
+     * @param data - Request data containing the user ID and new role
+     * @param data.user_id - ID of the user whose role is being updated
+     * @param data.role - New role to assign to the user
+     *
+     * @returns Promise resolving to an API response confirming the role update
+     *
+     * @throws {Error} When user_id or role is not provided
+     * @throws {Error} When the API request fails (includes status code and error details)
+     * @throws {Error} When the user doesn't have permission to update roles
+     * @throws {Error} When the specified user is not a member of the tenant
+     * @throws {Error} When the specified role is invalid or not allowed
+     *
+     * @example
+     * ```typescript
+     * // Update a user's role to admin
+     * try {
+     *   const result = await userManager.updateRole({
+     *     user_id: 'user_abc123',
+     *     role: 'admin'
+     *   });
+     *   console.log('Role updated successfully:', result.data.message);
+     * } catch (error) {
+     *   if (error.message.includes('403')) {
+     *     console.error('Insufficient permissions to update roles');
+     *   } else if (error.message.includes('404')) {
+     *     console.error('User not found in tenant');
+     *   } else {
+     *     console.error('Failed to update role:', error);
+     *   }
+     * }
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     * @group Tenant User Management
+     */
+    updateRole(data: UpdateTenantUserRoleRequest): Promise<UpdateTenantUserRoleResponse>;
+}
+
 /**
  * Main tenant management handler
  *
@@ -1841,7 +2139,6 @@ declare class TenantManger {
  * @group Tenant Management
  */
 declare class TenantHandler {
-    private omnibaseClient;
     /**
      * Creates a new TenantHandler instance
      *
@@ -1863,6 +2160,23 @@ declare class TenantHandler {
      * @group Tenant Management
      */
     constructor(omnibaseClient: OmnibaseClient);
+    /**
+     * Tenant user management operations
+     *
+     * Provides access to operations for managing users within tenants, including
+     * removing users from the active tenant. All operations respect user permissions
+     * and tenant ownership rules.
+     *
+     * @example
+     * ```typescript
+     * // Remove a user from the active tenant
+     * await tenantHandler.user.remove({ user_id: 'user_123' });
+     * ```
+     *
+     * @since 1.0.0
+     * @group Tenant Management
+     */
+    readonly user: TenantUserManager;
     /**
      * Core tenant management operations
      *
@@ -1943,7 +2257,21 @@ declare class OmnibaseClient {
     readonly payments: PaymentHandler;
     readonly tenants: TenantHandler;
     readonly permissions: PermissionsClient;
+    /**
+     * Storage client for file upload/download operations
+     *
+     * @example
+     * ```typescript
+     * // Upload with metadata
+     * await omnibase.storage.bucket('documents').upload(
+     *   'report.pdf',
+     *   file,
+     *   { metadata: { department: 'engineering' } }
+     * );
+     * ```
+     */
+    storage: StorageClient;
     fetch(endpoint: string, options?: RequestInit): Promise<Response>;
 }
 
-export { type AcceptTenantInviteRequest as A, type CreateTenantUserInviteResponse as C, CheckoutManager, type CheckoutOptions, ConfigManager, type CreateCheckoutResponse, type CreateCustomerPortalResponse, type DeleteTenantResponse as D, type OmnibaseClientConfig as O, PaymentHandler, PortalManager, type PortalOptions, type Price, type PriceDisplay, type PriceLimit, type PriceUI, type Product, type ProductUI, type ProductWithPricingUI, type SwitchActiveTenantResponse as S, type StripeConfigResponse, type StripeConfiguration, TenantHandler as T, type Tier, UsageManager, type UsageOptions, type AcceptTenantInviteResponse as a, type TenantInvite as b, type CreateTenantUserInviteRequest as c, TenantInviteManager as d, type CreateTenantResponse as e, type Tenant as f, type CreateTenantRequest as g, TenantManger as h, OmnibaseClient as i, type ApiResponse as j };
+export { type AcceptTenantInviteRequest as A, type CreateTenantUserInviteResponse as C, CheckoutManager, type CheckoutOptions, ConfigManager, type CreateCheckoutResponse, type CreateCustomerPortalResponse, type DownloadResult as D, type OmnibaseClientConfig as O, PaymentHandler, PortalManager, type PortalOptions, type Price, type PriceDisplay, type PriceLimit, type PriceUI, type Product, type ProductUI, type ProductWithPricingUI, StorageClient as S, type StripeConfigResponse, type StripeConfiguration, TenantHandler as T, type Tier, type UploadOptions as U, UsageManager, type UsageOptions, type UploadResult as a, type AcceptTenantInviteResponse as b, type TenantInvite as c, type CreateTenantUserInviteRequest as d, TenantInviteManager as e, type SwitchActiveTenantResponse as f, type DeleteTenantResponse as g, type CreateTenantResponse as h, type Tenant as i, type CreateTenantRequest as j, TenantManger as k, OmnibaseClient as l, type ApiResponse as m };

package/dist/storage/index.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  StorageClient: () => StorageClient
+});
+module.exports = __toCommonJS(storage_exports);
+var StorageClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Upload a file to storage
+   *
+   * @param path - Full path for the file (e.g., "public/images/avatar.png", "users/123/private/doc.pdf")
+   * @param file - File or Blob to upload
+   * @param options - Upload options including custom metadata
+   *
+   * @example
+   * ```typescript
+   * const result = await storage.upload(
+   *   'public/avatars/user-123.png',
+   *   file,
+   *   {
+   *     metadata: {
+   *       userId: '123',
+   *       uploadedBy: 'john@example.com',
+   *       tags: ['profile', 'avatar']
+   *     }
+   *   }
+   * );
+   *
+   * // File is automatically uploaded to S3 via the presigned URL
+   * console.log('File uploaded to:', result.path);
+   * ```
+   */
+  async upload(path, file, options) {
+    const metadata = {
+      // File metadata
+      filename: file instanceof File ? file.name : "blob",
+      size: file.size,
+      mime_type: file.type,
+      uploaded_at: (/* @__PURE__ */ new Date()).toISOString(),
+      // Merge custom metadata
+      ...options?.metadata || {}
+    };
+    const response = await this.client.fetch("/api/v1/storage/upload", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path,
+        metadata
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Upload failed" }));
+      throw new Error(error.error || "Failed to get upload URL");
+    }
+    const responseData = await response.json();
+    const result = responseData.data;
+    const uploadResponse = await fetch(result.upload_url, {
+      method: "PUT",
+      body: file,
+      headers: {
+        "Content-Type": file.type
+      }
+    });
+    if (!uploadResponse.ok) {
+      throw new Error("Failed to upload file to storage");
+    }
+    return result;
+  }
+  /**
+   * Download a file from storage
+   *
+   * @param path - Full path to the file
+   *
+   * @example
+   * ```typescript
+   * const { download_url } = await storage.download('public/images/logo.png');
+   *
+   * // Download the file
+   * const response = await fetch(download_url);
+   * const blob = await response.blob();
+   * ```
+   */
+  async download(path) {
+    const response = await this.client.fetch("/api/v1/storage/download", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Download failed" }));
+      throw new Error(error.error || "Failed to get download URL");
+    }
+    const responseData = await response.json();
+    return responseData.data;
+  }
+  /**
+   * Delete a file from storage
+   *
+   * @param path - Full path to the file
+   *
+   * @example
+   * ```typescript
+   * await storage.delete('users/123/documents/old-report.pdf');
+   * ```
+   */
+  async delete(path) {
+    const response = await this.client.fetch("/api/v1/storage/object", {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Delete failed" }));
+      throw new Error(error.error || "Failed to delete file");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageClient
+});

package/dist/storage/index.d.cts

@@ -0,0 +1,3 @@
+export { D as DownloadResult, S as StorageClient, U as UploadOptions, a as UploadResult } from '../payments/index.cjs';
+import '../permissions/index.cjs';
+import '@ory/client';

package/dist/storage/index.d.ts

@@ -0,0 +1,3 @@
+export { D as DownloadResult, S as StorageClient, U as UploadOptions, a as UploadResult } from '../payments/index.js';
+import '../permissions/index.js';
+import '@ory/client';

package/dist/storage/index.js

@@ -0,0 +1,6 @@
+import {
+  StorageClient
+} from "../chunk-I6DMWC32.js";
+export {
+  StorageClient
+};