@tspvivek/baasix-sdk 0.1.0-alpha.1 → 0.1.0-alpha.2

package/README.md

@@ -20,6 +20,9 @@ Official JavaScript/TypeScript SDK for [Baasix](https://www.baasix.com) Backend-
 - 🔀 **Workflows** - Execute and monitor workflow executions
 - 👥 **User & Role Management** - Admin operations for users and roles
 - 📊 **Reports** - Generate reports with aggregations
+- 🔔 **Notifications** - User notification system with realtime delivery
+- 🗃️ **Migrations** - Database schema migration management
+- 🔃 **Sort/Reorder** - Drag-and-drop style item reordering
 
 ## Installation
 
@@ -716,22 +719,36 @@ await baasix.roles.update(roleId, { description: 'Updated description' });
 
 ```typescript
 // Import from CSV file
-const result = await baasix.items('products').importCSV(csvFile, {
-  delimiter: ',',
-  skipFirstRow: true,
-});
-console.log(`Created: ${result.created}, Errors: ${result.errors.length}`);
+const result = await baasix.items('products').importCSV(csvFile);
+console.log(`Imported: ${result.imported}, Failed: ${result.failed}`);
 
 // Import from JSON file
 const result = await baasix.items('products').importJSON(jsonFile);
 
-// Import from data array
-const result = await baasix.items('products').importData([
+// Bulk create from data array
+const ids = await baasix.items('products').createMany([
   { name: 'Product 1', price: 29.99 },
   { name: 'Product 2', price: 39.99 },
 ]);
 ```
 
+## Sort / Reorder Items
+
+```typescript
+// Move item1 before item2
+await baasix.items('products').sortItem('item1-uuid', 'item2-uuid');
+
+// Move item1 after item2
+await baasix.items('products').sortItem('item1-uuid', 'item2-uuid', 'after');
+
+// Reorder multiple items (set explicit order)
+await baasix.items('products').reorder([
+  'item3-uuid',
+  'item1-uuid',
+  'item2-uuid'
+]);
+```
+
 ## Migrations (Admin)
 
 ```typescript
@@ -739,31 +756,66 @@ const result = await baasix.items('products').importData([
 const status = await baasix.migrations.status();
 console.log(`Pending: ${status.pendingCount}`);
 
+// Get pending migrations
+const pending = await baasix.migrations.pending();
+
 // Run pending migrations
-if (status.hasPending) {
-  const result = await baasix.migrations.run();
-  console.log(`Ran ${result.migrationsRun.length} migrations`);
-}
+const result = await baasix.migrations.run();
+console.log(`Completed: ${result.summary.completed}`);
+
+// Run with options
+const result = await baasix.migrations.run({
+  step: 1,      // Run only 1 migration
+  dryRun: true, // Preview without executing
+});
+
+// Rollback a specific migration
+await baasix.migrations.rollback('20231201000000');
 
 // Rollback last batch
-const rollback = await baasix.migrations.rollbackLast();
+await baasix.migrations.rollbackBatch();
+
+// Create new migration file
+const { filepath } = await baasix.migrations.create('add_status_column', {
+  type: 'schema',
+  description: 'Add status column to orders',
+});
+
+// Mark migrations as completed (without running)
+await baasix.migrations.markCompleted('20231201000000');
+await baasix.migrations.markAllCompleted();
 ```
 
 ## Notifications
 
 ```typescript
-// Get notifications
+// Get user notifications
 const { data } = await baasix.notifications.find({
   limit: 20,
-  seen: false,
+  filter: { seen: { eq: false } },
 });
 
-// Mark as seen
-await baasix.notifications.markAsSeen('notification-uuid');
-await baasix.notifications.markAllSeen();
-
 // Get unread count
 const count = await baasix.notifications.getUnreadCount();
+
+// Mark notifications as seen
+await baasix.notifications.markAsSeen(['id1', 'id2']);
+// Or mark all as seen
+await baasix.notifications.markAsSeen();
+
+// Delete notifications
+await baasix.notifications.delete(['id1', 'id2']);
+
+// Send notification (admin only)
+await baasix.notifications.send({
+  type: 'alert',
+  title: 'System Update',
+  message: 'Maintenance scheduled for tonight',
+  userIds: ['user1-uuid', 'user2-uuid'],
+});
+
+// Cleanup old notifications (admin only)
+await baasix.notifications.cleanup(30); // older than 30 days
 ```
 
 ## Custom Storage Adapter

package/dist/index.cjs

@@ -1607,38 +1607,23 @@ var ItemsModule = class {
    * const fileInput = document.querySelector('input[type="file"]');
    * const file = fileInput.files[0];
    * 
-   * const result = await baasix.items('products').importCSV(file, {
-   *   delimiter: ',',
-   *   skipFirstRow: true
-   * });
+   * const result = await baasix.items('products').importCSV(file);
    * 
-   * console.log(`Imported ${result.created} items`);
+   * console.log(`Imported ${result.imported} items`);
    * ```
    */
-  async importCSV(file, options) {
+  async importCSV(file) {
     const formData = new FormData();
     if (file instanceof File) {
-      formData.append("file", file);
+      formData.append("csvFile", file);
     } else {
-      formData.append("file", file);
-    }
-    if (options?.delimiter) {
-      formData.append("delimiter", options.delimiter);
-    }
-    if (options?.skipFirstRow !== void 0) {
-      formData.append("skipFirstRow", String(options.skipFirstRow));
-    }
-    if (options?.dateFormat) {
-      formData.append("dateFormat", options.dateFormat);
-    }
-    if (options?.fieldMapping) {
-      formData.append("fieldMapping", JSON.stringify(options.fieldMapping));
+      formData.append("csvFile", file);
     }
     const response = await this.client.post(
-      `/items/${this.collection}/import/csv`,
+      `/items/${this.collection}/import-csv`,
       formData
     );
-    return response.data;
+    return response.results;
   }
   /**
    * Import items from a JSON file
@@ -1648,24 +1633,21 @@ var ItemsModule = class {
    * const file = fileInput.files[0]; // JSON file
    * const result = await baasix.items('products').importJSON(file);
    * 
-   * console.log(`Imported ${result.created} items`);
+   * console.log(`Imported ${result.imported} items`);
    * ```
    */
-  async importJSON(file, options) {
+  async importJSON(file) {
     const formData = new FormData();
     if (file instanceof File) {
-      formData.append("file", file);
+      formData.append("jsonFile", file);
     } else {
-      formData.append("file", file);
-    }
-    if (options?.fieldMapping) {
-      formData.append("fieldMapping", JSON.stringify(options.fieldMapping));
+      formData.append("jsonFile", file);
     }
     const response = await this.client.post(
-      `/items/${this.collection}/import/json`,
+      `/items/${this.collection}/import-json`,
       formData
     );
-    return response.data;
+    return response.results;
   }
   /**
    * Import items from an array of objects
@@ -1691,19 +1673,22 @@ var ItemsModule = class {
   // Sort Operations
   // ===================
   /**
-   * Sort/reorder items (move item before another)
+   * Sort/reorder items (move item before or after another)
    *
    * @example
    * ```typescript
    * // Move item1 before item2
    * await baasix.items('products').sortItem('item1-uuid', 'item2-uuid');
+   * 
+   * // Move item1 after item2
+   * await baasix.items('products').sortItem('item1-uuid', 'item2-uuid', 'after');
    * ```
    */
-  async sortItem(itemId, beforeItemId) {
-    await this.client.post("/utils/sort", {
-      collection: this.collection,
+  async sortItem(itemId, targetItemId, mode = "before") {
+    await this.client.post(`/utils/sort/${this.collection}`, {
       item: itemId,
-      to: beforeItemId
+      to: targetItemId,
+      mode
     });
   }
   /**
@@ -1721,10 +1706,10 @@ var ItemsModule = class {
    */
   async reorder(orderedIds) {
     for (let i = 1; i < orderedIds.length; i++) {
-      await this.client.post("/utils/sort", {
-        collection: this.collection,
+      await this.client.post(`/utils/sort/${this.collection}`, {
         item: orderedIds[i],
-        to: orderedIds[i - 1]
+        to: orderedIds[i - 1],
+        mode: "after"
       });
     }
   }
@@ -2004,10 +1989,13 @@ var SchemasModule = class {
    * ```typescript
    * const { data } = await baasix.schemas.find();
    * console.log(data.map(s => s.collectionName));
+   * 
+   * // With pagination
+   * const { data } = await baasix.schemas.find({ page: 1, limit: 50 });
    * ```
    */
-  async find() {
-    return this.client.get("/schemas");
+  async find(params) {
+    return this.client.get("/schemas", { params });
   }
   /**
    * Get schema for a specific collection
@@ -2150,6 +2138,23 @@ var SchemasModule = class {
       `/schemas/${collection}/relationships/${relationshipName}`
     );
   }
+  /**
+   * Update a relationship
+   *
+   * @example
+   * ```typescript
+   * await baasix.schemas.updateRelationship('posts', 'author', {
+   *   alias: 'authoredPosts',
+   *   onDelete: 'CASCADE'
+   * });
+   * ```
+   */
+  async updateRelationship(collection, relationshipName, data) {
+    await this.client.patch(
+      `/schemas/${collection}/relationships/${relationshipName}`,
+      data
+    );
+  }
   /**
    * Create an index on a collection
    *
@@ -2278,71 +2283,56 @@ var NotificationsModule = class {
     });
   }
   /**
-   * Get a single notification by ID
-   */
-  async findOne(id) {
-    const response = await this.client.get(
-      `/notifications/${id}`
-    );
-    return response.data;
-  }
-  /**
-   * Mark a notification as seen
-   *
-   * @example
-   * ```typescript
-   * await baasix.notifications.markAsSeen('notification-uuid');
-   * ```
-   */
-  async markAsSeen(id) {
-    await this.client.patch(`/notifications/${id}/seen`, { seen: true });
-  }
-  /**
-   * Mark multiple notifications as seen
-   *
-   * @example
-   * ```typescript
-   * await baasix.notifications.markManySeen(['id1', 'id2', 'id3']);
-   * ```
-   */
-  async markManySeen(ids) {
-    await Promise.all(ids.map((id) => this.markAsSeen(id)));
-  }
-  /**
-   * Mark all notifications as seen
+   * Get unread notification count
    *
    * @example
    * ```typescript
-   * await baasix.notifications.markAllSeen();
+   * const count = await baasix.notifications.getUnreadCount();
    * ```
    */
-  async markAllSeen() {
-    await this.client.post("/notifications/seen-all");
+  async getUnreadCount() {
+    const response = await this.client.get(
+      "/notifications/unread/count"
+    );
+    return response.count;
   }
   /**
-   * Get unread notification count
+   * Mark notifications as seen
    *
    * @example
    * ```typescript
-   * const count = await baasix.notifications.getUnreadCount();
+   * // Mark specific notifications as seen
+   * await baasix.notifications.markAsSeen(['id1', 'id2']);
+   * 
+   * // Mark all notifications as seen
+   * await baasix.notifications.markAsSeen();
    * ```
    */
-  async getUnreadCount() {
-    const response = await this.client.get(
-      "/notifications/unread-count"
+  async markAsSeen(notificationIds) {
+    const response = await this.client.post(
+      "/notifications/mark-seen",
+      { notificationIds }
     );
-    return response.data.count;
+    return { count: response.count };
   }
   /**
-   * Delete a notification
+   * Delete notifications for the current user
    *
    * @example
    * ```typescript
-   * await baasix.notifications.delete('notification-uuid');
+   * // Delete specific notifications
+   * await baasix.notifications.delete(['id1', 'id2']);
+   * 
+   * // Delete all notifications
+   * await baasix.notifications.delete();
    * ```
    */
-  async delete(id) {
-    await this.client.delete(`/notifications/${id}`);
+  async delete(notificationIds) {
+    const response = await this.client.delete(
+      "/notifications",
+      { params: notificationIds ? { notificationIds } : void 0 }
+    );
+    return { count: response.count };
   }
   /**
    * Send a notification to users (requires admin permissions)
@@ -2359,7 +2349,30 @@ var NotificationsModule = class {
    * ```
    */
   async send(data) {
-    await this.client.post("/notifications/send", data);
+    const response = await this.client.post(
+      "/notifications/send",
+      data
+    );
+    return { notificationIds: response.notificationIds };
+  }
+  /**
+   * Cleanup old notifications (requires admin permissions)
+   *
+   * @example
+   * ```typescript
+   * // Clean up notifications older than 30 days (default)
+   * await baasix.notifications.cleanup();
+   * 
+   * // Clean up notifications older than 7 days
+   * await baasix.notifications.cleanup(7);
+   * ```
+   */
+  async cleanup(days = 30) {
+    const response = await this.client.post(
+      "/notifications/cleanup",
+      { days }
+    );
+    return { count: response.count };
   }
 };
 
@@ -3716,15 +3729,21 @@ var MigrationsModule = class {
     return response.data;
   }
   /**
-   * Get all completed migrations
+   * Get all migrations with optional filtering
    * 
    * @example
    * ```typescript
+   * // Get all migrations
    * const migrations = await baasix.migrations.list();
+   * 
+   * // Get completed migrations
+   * const completed = await baasix.migrations.list({ status: 'completed' });
    * ```
    */
-  async list() {
-    const response = await this.client.get("/migrations");
+  async list(options) {
+    const response = await this.client.get("/migrations", {
+      params: options
+    });
     return response.data;
   }
   /**
@@ -3742,31 +3761,34 @@ var MigrationsModule = class {
     return response.data;
   }
   /**
-   * Check if there are pending migrations
+   * Check if migrations are needed
    * 
    * @example
    * ```typescript
-   * const needsMigration = await baasix.migrations.hasPending();
+   * const check = await baasix.migrations.check();
+   * if (check.hasPending) {
+   *   console.log('Migrations needed');
+   * }
    * ```
    */
-  async hasPending() {
+  async check() {
     const response = await this.client.get(
       "/migrations/check"
     );
-    return response.data.hasPending;
+    return response.data;
   }
   /**
-   * Get a specific migration by name
+   * Get a specific migration by version
    * 
    * @example
    * ```typescript
-   * const migration = await baasix.migrations.get('20231201_create_users');
+   * const migration = await baasix.migrations.get('20231201000000');
    * ```
    */
-  async get(name) {
+  async get(version) {
     try {
       const response = await this.client.get(
-        `/migrations/${encodeURIComponent(name)}`
+        `/migrations/${encodeURIComponent(version)}`
       );
       return response.data;
     } catch {
@@ -3778,14 +3800,20 @@ var MigrationsModule = class {
    * 
    * @example
    * ```typescript
+   * // Run all pending migrations
    * const result = await baasix.migrations.run();
-   * console.log(`Ran ${result.migrationsRun.length} migrations`);
+   * 
+   * // Run with options
+   * const result = await baasix.migrations.run({
+   *   step: 1,  // Run only 1 migration
+   *   dryRun: true  // Preview without executing
+   * });
    * ```
    */
-  async run() {
+  async run(options) {
     const response = await this.client.post(
       "/migrations/run",
-      {}
+      options || {}
     );
     return response.data;
   }
@@ -3794,13 +3822,13 @@ var MigrationsModule = class {
    * 
    * @example
    * ```typescript
-   * const result = await baasix.migrations.rollback('20231201_create_users');
+   * const result = await baasix.migrations.rollback('20231201000000');
    * ```
    */
-  async rollback(name) {
+  async rollback(version) {
     const response = await this.client.post(
-      "/migrations/rollback",
-      { name }
+      `/migrations/rollback/${encodeURIComponent(version)}`,
+      {}
     );
     return response.data;
   }
@@ -3809,12 +3837,12 @@ var MigrationsModule = class {
    * 
    * @example
    * ```typescript
-   * const result = await baasix.migrations.rollbackLast();
+   * const result = await baasix.migrations.rollbackBatch();
    * ```
    */
-  async rollbackLast() {
+  async rollbackBatch() {
     const response = await this.client.post(
-      "/migrations/rollback-last",
+      "/migrations/rollback-batch",
       {}
     );
     return response.data;
@@ -3824,37 +3852,91 @@ var MigrationsModule = class {
    * 
    * @example
    * ```typescript
-   * const migrationName = await baasix.migrations.create('add_status_column');
+   * const { filepath } = await baasix.migrations.create('add_status_column', {
+   *   type: 'schema',
+   *   description: 'Add status column to orders'
+   * });
    * ```
    */
-  async create(name) {
+  async create(name, options) {
     const response = await this.client.post(
       "/migrations/create",
-      { name }
+      { name, ...options }
     );
-    return response.data.name;
+    return response.data;
   }
   /**
-   * Mark a migration as complete (without running it)
+   * Mark a specific migration as completed without running it
+   * Useful for existing installations that already have the changes
    * 
    * @example
    * ```typescript
-   * await baasix.migrations.markComplete('20231201_create_users');
+   * await baasix.migrations.markCompleted('20231201000000');
    * ```
    */
-  async markComplete(name) {
-    await this.client.post("/migrations/mark-complete", { name });
+  async markCompleted(version, metadata) {
+    const response = await this.client.post(
+      `/migrations/mark-completed/${encodeURIComponent(version)}`,
+      { metadata }
+    );
+    return response.data;
   }
   /**
-   * Mark all pending migrations as complete
+   * Mark all pending migrations as completed
+   * Useful for bringing an existing database up to date without running migrations
    * 
    * @example
    * ```typescript
-   * await baasix.migrations.markAllComplete();
+   * // Mark all pending
+   * await baasix.migrations.markAllCompleted();
+   * 
+   * // Mark up to a specific version
+   * await baasix.migrations.markAllCompleted('20231201000000');
+   * ```
+   */
+  async markAllCompleted(toVersion) {
+    const response = await this.client.post(
+      "/migrations/mark-all-completed",
+      { toVersion }
+    );
+    return response.data;
+  }
+};
+
+// src/modules/server.ts
+var ServerModule = class {
+  client;
+  constructor(config) {
+    this.client = config.client;
+  }
+  /**
+   * Get server information including project settings
+   *
+   * @example
+   * ```typescript
+   * const info = await baasix.server.info();
+   * console.log('Project:', info.project?.name);
+   * console.log('Version:', info.version);
+   * ```
+   */
+  async info() {
+    return this.client.get("/");
+  }
+  /**
+   * Check server health
+   *
+   * @example
+   * ```typescript
+   * const isHealthy = await baasix.server.health();
    * ```
    */
-  async markAllComplete() {
-    await this.client.post("/migrations/mark-all-complete", {});
+  async health() {
+    try {
+      await this.client.get("/health");
+      return true;
+    } catch {
+      return false;
+    }
   }
 };
 
@@ -3933,6 +4015,7 @@ var Baasix = class {
   roles;
   users;
   migrations;
+  server;
   // Items module factory cache
   itemsModules = /* @__PURE__ */ new Map();
   constructor(config) {
@@ -3981,6 +4064,7 @@ var Baasix = class {
     this.roles = new RolesModule({ client: this.httpClient });
     this.users = new UsersModule({ client: this.httpClient });
     this.migrations = new MigrationsModule({ client: this.httpClient });
+    this.server = new ServerModule({ client: this.httpClient });
     this.realtime = new RealtimeModule({
       client: this.httpClient,
       storage: this.storage,
@@ -4109,6 +4193,23 @@ var Baasix = class {
     this.httpClient.updateConfig({ tenantId: void 0 });
     await this.storage.remove(STORAGE_KEYS.TENANT);
   }
+  /**
+   * Set a static token (convenience method that delegates to auth.setToken)
+   *
+   * @example
+   * ```typescript
+   * baasix.setToken('your-api-token');
+   * ```
+   */
+  async setToken(token) {
+    return this.auth.setToken(token);
+  }
+  /**
+   * Get the current auth token
+   */
+  async getToken() {
+    return this.storage.get(STORAGE_KEYS.ACCESS_TOKEN);
+  }
   /**
    * Get the base URL
    */