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

package/dist/index.js

@@ -1605,38 +1605,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
@@ -1646,24 +1631,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
@@ -1689,19 +1671,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
     });
   }
   /**
@@ -1719,10 +1704,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"
       });
     }
   }
@@ -2002,10 +1987,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
@@ -2148,6 +2136,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
    *
@@ -2276,71 +2281,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)
@@ -2357,7 +2347,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 };
   }
 };
 
@@ -3714,15 +3727,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;
   }
   /**
@@ -3740,31 +3759,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 {
@@ -3776,14 +3798,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;
   }
@@ -3792,13 +3820,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;
   }
@@ -3807,12 +3835,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;
@@ -3822,37 +3850,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;
+    }
   }
 };
 
@@ -3931,6 +4013,7 @@ var Baasix = class {
   roles;
   users;
   migrations;
+  server;
   // Items module factory cache
   itemsModules = /* @__PURE__ */ new Map();
   constructor(config) {
@@ -3979,6 +4062,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,
@@ -4107,6 +4191,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
    */