@omnibase/core-js 0.5.10 → 0.7.0

package/dist/payments/index.js

@@ -4,7 +4,7 @@ import {
   PaymentHandler,
   PortalManager,
   UsageManager
-} from "../chunk-PNP3T7XU.js";
+} from "../chunk-QPW6G4PA.js";
 export {
   CheckoutManager,
   ConfigManager,

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
+};

package/dist/tenants/index.cjs

@@ -68,17 +68,6 @@ var TenantInviteManager = class {
    * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
    *
    * @example
-   * Basic invitation acceptance:
-   * ```typescript
-   * const result = await acceptTenantInvite('inv_secure_token_abc123');
-   *
-   * console.log(`Successfully joined tenant: ${result.data.tenant_id}`);
-   * // User can now access tenant resources
-   * await switchActiveTenant(result.data.tenant_id);
-   * ```
-   *
-   * @example
-   * Handling the invitation flow:
    * ```typescript
    * // Typically called from an invitation link like:
    * // https://app.com/accept-invite?token=inv_secure_token_abc123
@@ -88,21 +77,20 @@ var TenantInviteManager = class {
    *
    * if (inviteToken) {
    *   try {
-   *     const result = await acceptTenantInvite(inviteToken);
+   *     const result = await inviteManager.accept(inviteToken);
    *
    *     // Success - redirect to tenant dashboard
+   *     console.log(`Successfully joined tenant: ${result.data.tenant_id}`);
    *     window.location.href = `/dashboard?tenant=${result.data.tenant_id}`;
    *   } catch (error) {
    *     console.error('Failed to accept invitation:', error.message);
-   *     // Show error to user
    *   }
    * }
    * ```
    *
-   *
-   * @since 1.0.0
+   * @since 0.6.0
    * @public
-   * @group User Management
+   * @group Tenant Invitations
    */
   async accept(token) {
     if (!token) {
@@ -137,73 +125,58 @@ var TenantInviteManager = class {
     }
   }
   /**
-   * Creates a new user invitation for a specific tenant
+   * Creates a new user invitation for the active tenant
    *
-   * Generates a secure invitation that allows a user to join the specified
-   * tenant with the defined role. The invitation is sent to the provided
-   * email address and includes a time-limited token for security.
+   * Generates a secure invitation that allows a user to join the currently active
+   * tenant with the defined role. The invitation is sent to the provided email address
+   * and includes a time-limited token for security. The invite URL will be automatically
+   * appended with ?token=XYZ when sent to the user.
    *
-   * The function creates the invitation record in the database and can
-   * trigger email notifications (depending on server configuration).
-   * The invitation expires after a predefined time period and can only
+   * The function creates the invitation record in the database and triggers an email
+   * notification to the invited user. The invitation expires after 7 days and can only
    * be used once.
    *
-   * Only existing tenant members with appropriate permissions can create
-   * invitations. The inviter's authentication is validated via HTTP-only
-   * cookies sent with the request.
+   * Only existing tenant members with appropriate permissions (invite_user permission)
+   * can create invitations. The inviter's authentication and tenant context are validated
+   * via HTTP-only cookies sent with the request.
    *
-   * @param tenantId - Unique identifier of the tenant to invite the user to
    * @param inviteData - Configuration object for the invitation
    * @param inviteData.email - Email address of the user to invite
    * @param inviteData.role - Role the user will have after joining (e.g., 'member', 'admin')
+   * @param inviteData.invite_url - Base URL for the invitation link (will be appended with ?token=XYZ)
    *
    * @returns Promise resolving to the created invitation with secure token
    *
-   * @throws {Error} When tenantId parameter is missing or empty
-   * @throws {Error} When required fields (email, role) are missing or empty
+   * @throws {Error} When required fields (email, role, invite_url) are missing or empty
+   * @throws {Error} When the user doesn't have permission to invite users to the tenant
    * @throws {Error} When the API request fails due to network issues
    * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
    *
    * @example
-   * Basic invitation creation:
    * ```typescript
-   * const invite = await createTenantUserInvite('tenant_123', {
+   * const invite = await inviteManager.create({
    *   email: 'colleague@company.com',
-   *   role: 'member'
+   *   role: 'member',
+   *   invite_url: 'https://yourapp.com/accept-invite'
    * });
    *
    * console.log(`Invite sent to: ${invite.data.invite.email}`);
-   * // The invite token can be used to generate invitation links
-   * const inviteLink = `https://app.com/accept-invite?token=${invite.data.invite.token}`;
+   * console.log(`Invite token: ${invite.data.invite.token}`);
    * ```
    *
-   * @example
-   * Creating admin invitation:
-   * ```typescript
-   * const adminInvite = await createTenantUserInvite('tenant_456', {
-   *   email: 'admin@company.com',
-   *   role: 'admin'
-   * });
-   *
-   * // Admin users get elevated permissions
-   * console.log(`Admin invite created with ID: ${adminInvite.data.invite.id}`);
-   * ```
-   *
-   *
-   * @since 1.0.0
+   * @since 0.6.0
    * @public
-   * @group User Management
+   * @group Tenant Invitations
    */
-  async create(tenantId, inviteData) {
-    if (!tenantId) {
-      throw new Error("Tenant ID is required");
-    }
-    if (!inviteData.email || !inviteData.role) {
-      throw new Error("Email and role are required");
+  async create(inviteData) {
+    if (!inviteData.email || !inviteData.role || !inviteData.invite_url) {
+      throw new Error(
+        "Missing data in `create` - email, role, and invite_url are required"
+      );
     }
     try {
       const response = await this.omnibaseClient.fetch(
-        `/api/v1/tenants/${tenantId}/invites`,
+        `/api/v1/tenants/invites`,
         {
           method: "POST",
           headers: {
@@ -267,21 +240,17 @@ var TenantManger = class {
    * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
    *
    * @example
-   * Basic tenant creation:
    * ```typescript
-   * const newTenant = await createTenant({
+   * const newTenant = await tenantManager.createTenant({
    *   name: 'Acme Corporation',
    *   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);
+   * console.log(`Tenant created: ${newTenant.data.tenant.id}`);
    * ```
    *
-   *
-   * @since 1.0.0
+   * @since 0.6.0
    * @public
    * @group Tenant Management
    */
@@ -346,7 +315,6 @@ var TenantManger = class {
    * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
    *
    * @example
-   * Basic tenant deletion with confirmation:
    * ```typescript
    * const tenantToDelete = 'tenant_abc123';
    *
@@ -357,8 +325,8 @@ var TenantManger = class {
    *
    * if (userConfirmed) {
    *   try {
-   *     const result = await deleteTenant(tenantToDelete);
-   *     console.log(result.data.message); // "Tenant deleted successfully"
+   *     const result = await tenantManager.deleteTenant(tenantToDelete);
+   *     console.log(result.data.message);
    *
    *     // Redirect user away from deleted tenant
    *     window.location.href = '/dashboard';
@@ -368,7 +336,7 @@ var TenantManger = class {
    * }
    * ```
    *
-   * @since 1.0.0
+   * @since 0.6.0
    * @public
    * @group Tenant Management
    */
@@ -431,46 +399,17 @@ var TenantManger = class {
    * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
    *
    * @example
-   * Basic tenant switching:
    * ```typescript
-   * const result = await switchActiveTenant('tenant_xyz789');
+   * const result = await tenantManager.switchActiveTenant('tenant_xyz789');
+   *
+   * // Store the new token for future requests
+   * console.log(`Switched to tenant. New token: ${result.data.token}`);
    *
    * // Now all API calls will be in the context of tenant_xyz789
    * const tenantData = await getCurrentTenantData();
    * ```
    *
-   * @example
-   * Using with tenant-aware data fetching:
-   * ```typescript
-   * // Switch tenant and immediately fetch tenant-specific data
-   * const switchAndLoadTenant = async (tenantId: string) => {
-   *   try {
-   *     // Switch to new tenant context
-   *     const switchResult = await switchActiveTenant(tenantId);
-   *
-   *     // Update authentication token
-   *     setAuthToken(switchResult.data.token);
-   *
-   *     // Fetch data in new tenant context
-   *     const [tenantInfo, userPermissions, tenantSettings] = await Promise.all([
-   *       getTenantInfo(),
-   *       getUserPermissions(),
-   *       getTenantSettings()
-   *     ]);
-   *
-   *     return {
-   *       tenant: tenantInfo,
-   *       permissions: userPermissions,
-   *       settings: tenantSettings
-   *     };
-   *   } catch (error) {
-   *     console.error('Failed to switch tenant and load data:', error);
-   *     throw error;
-   *   }
-   * };
-   * ```
-   *
-   * @since 1.0.0
+   * @since 0.6.0
    * @public
    * @group Tenant Management
    */
@@ -508,6 +447,140 @@ var TenantManger = class {
   }
 };
 
+// src/tenants/user.ts
+var TenantUserManager = class {
+  /**
+   * Creates a new tenant user manager
+   *
+   * @param omnibaseClient - Configured OmnibaseClient instance for API communication
+   *
+   * @group Tenant User Management
+   */
+  constructor(omnibaseClient) {
+    this.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 0.6.0
+   * @public
+   * @group Tenant User Management
+   */
+  async remove(data) {
+    if (!data.user_id) {
+      throw new Error("user_id is required");
+    }
+    const response = await this.omnibaseClient.fetch("/api/v1/tenants/users", {
+      method: "DELETE",
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(
+        `Failed to delete user from tenant: ${response.status} - ${errorData}`
+      );
+    }
+    return await response.json();
+  }
+  /**
+   * 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 0.6.0
+   * @public
+   * @group Tenant User Management
+   */
+  async updateRole(data) {
+    if (!data.role || !data.user_id)
+      throw new Error("user_id and role is required");
+    const response = await this.omnibaseClient.fetch("/api/v1/tenants/users", {
+      method: "PUT",
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(
+        `Failed to update users role: ${response.status} - ${errorData}`
+      );
+    }
+    return await response.json();
+  }
+};
+
 // src/tenants/handler.ts
 var TenantHandler = class {
   /**
@@ -531,10 +604,27 @@ var TenantHandler = class {
    * @group Tenant Management
    */
   constructor(omnibaseClient) {
-    this.omnibaseClient = omnibaseClient;
-    this.invites = new TenantInviteManager(this.omnibaseClient);
-    this.manage = new TenantManger(this.omnibaseClient);
+    this.invites = new TenantInviteManager(omnibaseClient);
+    this.manage = new TenantManger(omnibaseClient);
+    this.user = new TenantUserManager(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 0.6.0
+   * @group Tenant Management
+   */
+  user;
   /**
    * Core tenant management operations
    *
@@ -545,17 +635,17 @@ var TenantHandler = class {
    * @example
    * ```typescript
    * // Create a new tenant
-   * const tenant = await tenantHandler.tenants.createTenant({
+   * const tenant = await tenantHandler.manage.createTenant({
    *   name: 'New Company',
    *   billing_email: 'billing@newcompany.com',
    *   user_id: 'user_456'
    * });
    *
    * // Switch to the tenant
-   * await tenantHandler.tenants.switchActiveTenant(tenant.data.tenant.id);
+   * await tenantHandler.manage.switchActiveTenant(tenant.data.tenant.id);
    *
    * // Delete the tenant (owner only)
-   * await tenantHandler.tenants.deleteTenant(tenant.data.tenant.id);
+   * await tenantHandler.manage.deleteTenant(tenant.data.tenant.id);
    * ```
    */
   manage;
@@ -569,9 +659,10 @@ var TenantHandler = class {
    * @example
    * ```typescript
    * // Create an invitation
-   * const invite = await tenantHandler.invites.create('tenant_123', {
+   * const invite = await tenantHandler.invites.create({
    *   email: 'newuser@company.com',
-   *   role: 'admin'
+   *   role: 'admin',
+   *   invite_url: 'https://yourapp.com/accept-invite'
    * });
    *
    * // Accept an invitation (from the invited user's session)

package/dist/tenants/index.d.cts

@@ -1,3 +1,3 @@
-export { A as AcceptTenantInviteRequest, a as AcceptTenantInviteResponse, g as CreateTenantRequest, e as CreateTenantResponse, c as CreateTenantUserInviteRequest, C as CreateTenantUserInviteResponse, D as DeleteTenantResponse, S as SwitchActiveTenantResponse, f as Tenant, T as TenantHandler, b as TenantInvite, d as TenantInviteManager, h as TenantManger } from '../payments/index.cjs';
+export { A as AcceptTenantInviteRequest, b as AcceptTenantInviteResponse, j as CreateTenantRequest, h as CreateTenantResponse, d as CreateTenantUserInviteRequest, C as CreateTenantUserInviteResponse, g as DeleteTenantResponse, f as SwitchActiveTenantResponse, i as Tenant, T as TenantHandler, c as TenantInvite, e as TenantInviteManager, k as TenantManger } from '../payments/index.cjs';
 import '../permissions/index.cjs';
 import '@ory/client';

package/dist/tenants/index.d.ts

@@ -1,3 +1,3 @@
-export { A as AcceptTenantInviteRequest, a as AcceptTenantInviteResponse, g as CreateTenantRequest, e as CreateTenantResponse, c as CreateTenantUserInviteRequest, C as CreateTenantUserInviteResponse, D as DeleteTenantResponse, S as SwitchActiveTenantResponse, f as Tenant, T as TenantHandler, b as TenantInvite, d as TenantInviteManager, h as TenantManger } from '../payments/index.js';
+export { A as AcceptTenantInviteRequest, b as AcceptTenantInviteResponse, j as CreateTenantRequest, h as CreateTenantResponse, d as CreateTenantUserInviteRequest, C as CreateTenantUserInviteResponse, g as DeleteTenantResponse, f as SwitchActiveTenantResponse, i as Tenant, T as TenantHandler, c as TenantInvite, e as TenantInviteManager, k as TenantManger } from '../payments/index.js';
 import '../permissions/index.js';
 import '@ory/client';

package/dist/tenants/index.js

@@ -1,6 +1,6 @@
 import {
   TenantHandler
-} from "../chunk-L7EZC6WP.js";
+} from "../chunk-6OGESVXW.js";
 export {
   TenantHandler
 };