@openmdm/drizzle-adapter 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present OpenMDM Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-ULFOOXEW.js

@@ -0,0 +1,11 @@
+// src/schema.ts
+import { mdmSchema, getTableNames, getColumnNames } from "@openmdm/core/schema";
+var DEFAULT_TABLE_PREFIX = "mdm_";
+
+export {
+  DEFAULT_TABLE_PREFIX,
+  mdmSchema,
+  getTableNames,
+  getColumnNames
+};
+//# sourceMappingURL=chunk-ULFOOXEW.js.map

package/dist/chunk-ULFOOXEW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["/**\n * OpenMDM Drizzle Schema\n *\n * This file exports the schema definition for use with schema generators.\n * For ready-to-use Drizzle tables, import from:\n * - @openmdm/drizzle-adapter/postgres\n * - @openmdm/drizzle-adapter/mysql\n * - @openmdm/drizzle-adapter/sqlite\n */\n\nexport { mdmSchema, getTableNames, getColumnNames } from '@openmdm/core/schema';\n\n/**\n * Table prefix for MDM tables.\n * Can be customized via the adapter options.\n */\nexport const DEFAULT_TABLE_PREFIX = 'mdm_';\n\n/**\n * Schema options for customizing table generation\n */\nexport interface SchemaOptions {\n  /** Prefix for all MDM tables (default: 'mdm_') */\n  tablePrefix?: string;\n  /** Custom schema name (PostgreSQL only) */\n  schema?: string;\n}\n"],"mappings":";AAUA,SAAS,WAAW,eAAe,sBAAsB;AAMlD,IAAM,uBAAuB;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { DatabaseAdapter } from '@openmdm/core';
+import { mdmDevices, mdmPolicies, mdmApplications, mdmCommands, mdmEvents, mdmGroups, mdmDeviceGroups, mdmPushTokens } from './postgres.js';
+export { DEFAULT_TABLE_PREFIX, SchemaOptions } from './schema.js';
+import 'drizzle-orm';
+import 'drizzle-orm/pg-core';
+import '@openmdm/core/schema';
+
+/**
+ * OpenMDM Drizzle Adapter
+ *
+ * Database adapter for Drizzle ORM, supporting PostgreSQL, MySQL, and SQLite.
+ *
+ * @example
+ * ```typescript
+ * import { drizzle } from 'drizzle-orm/node-postgres';
+ * import { drizzleAdapter } from '@openmdm/drizzle-adapter';
+ * import { mdmSchema } from '@openmdm/drizzle-adapter/postgres';
+ * import { createMDM } from '@openmdm/core';
+ *
+ * const pool = new Pool({ connectionString: DATABASE_URL });
+ * const db = drizzle(pool, { schema: mdmSchema });
+ *
+ * const mdm = createMDM({
+ *   database: drizzleAdapter(db),
+ *   // ...
+ * });
+ * ```
+ */
+
+type DrizzleDB = {
+    select: (columns?: unknown) => unknown;
+    insert: (table: unknown) => unknown;
+    update: (table: unknown) => unknown;
+    delete: (table: unknown) => unknown;
+    query: Record<string, unknown>;
+    transaction: <T>(fn: (tx: DrizzleDB) => Promise<T>) => Promise<T>;
+};
+interface DrizzleAdapterOptions {
+    /**
+     * Table references - pass your imported Drizzle tables
+     */
+    tables: {
+        devices: typeof mdmDevices;
+        policies: typeof mdmPolicies;
+        applications: typeof mdmApplications;
+        commands: typeof mdmCommands;
+        events: typeof mdmEvents;
+        groups: typeof mdmGroups;
+        deviceGroups: typeof mdmDeviceGroups;
+        pushTokens: typeof mdmPushTokens;
+    };
+}
+/**
+ * Create a Drizzle database adapter for OpenMDM
+ */
+declare function drizzleAdapter(db: DrizzleDB, options: DrizzleAdapterOptions): DatabaseAdapter;
+
+export { type DrizzleAdapterOptions, drizzleAdapter };

package/dist/index.js

@@ -0,0 +1,588 @@
+import {
+  DEFAULT_TABLE_PREFIX
+} from "./chunk-ULFOOXEW.js";
+
+// src/index.ts
+import { eq, and, or, like, inArray, desc, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+function drizzleAdapter(db, options) {
+  const { tables } = options;
+  const {
+    devices,
+    policies,
+    applications,
+    commands,
+    events,
+    groups,
+    deviceGroups,
+    pushTokens
+  } = tables;
+  const generateId = () => nanoid(21);
+  const toDevice = (row) => ({
+    id: row.id,
+    externalId: row.externalId,
+    enrollmentId: row.enrollmentId,
+    status: row.status,
+    model: row.model,
+    manufacturer: row.manufacturer,
+    osVersion: row.osVersion,
+    serialNumber: row.serialNumber,
+    imei: row.imei,
+    macAddress: row.macAddress,
+    androidId: row.androidId,
+    policyId: row.policyId,
+    lastHeartbeat: row.lastHeartbeat,
+    lastSync: row.lastSync,
+    batteryLevel: row.batteryLevel,
+    storageUsed: row.storageUsed,
+    storageTotal: row.storageTotal,
+    location: row.latitude && row.longitude ? {
+      latitude: parseFloat(row.latitude),
+      longitude: parseFloat(row.longitude),
+      timestamp: row.locationTimestamp
+    } : null,
+    installedApps: row.installedApps,
+    tags: row.tags,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+  const toPolicy = (row) => ({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    isDefault: row.isDefault,
+    settings: row.settings,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+  const toApplication = (row) => ({
+    id: row.id,
+    name: row.name,
+    packageName: row.packageName,
+    version: row.version,
+    versionCode: row.versionCode,
+    url: row.url,
+    hash: row.hash,
+    size: row.size,
+    minSdkVersion: row.minSdkVersion,
+    showIcon: row.showIcon,
+    runAfterInstall: row.runAfterInstall,
+    runAtBoot: row.runAtBoot,
+    isSystem: row.isSystem,
+    isActive: row.isActive,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+  const toCommand = (row) => ({
+    id: row.id,
+    deviceId: row.deviceId,
+    type: row.type,
+    payload: row.payload,
+    status: row.status,
+    result: row.result,
+    error: row.error,
+    createdAt: row.createdAt,
+    sentAt: row.sentAt,
+    acknowledgedAt: row.acknowledgedAt,
+    completedAt: row.completedAt
+  });
+  const toEvent = (row) => ({
+    id: row.id,
+    deviceId: row.deviceId,
+    type: row.type,
+    payload: row.payload,
+    createdAt: row.createdAt
+  });
+  const toGroup = (row) => ({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    policyId: row.policyId,
+    parentId: row.parentId,
+    metadata: row.metadata,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+  const toPushToken = (row) => ({
+    id: row.id,
+    deviceId: row.deviceId,
+    provider: row.provider,
+    token: row.token,
+    isActive: row.isActive,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+  return {
+    // ============================================
+    // Device Methods
+    // ============================================
+    async findDevice(id) {
+      const result = await db.select().from(devices).where(eq(devices.id, id)).limit(1);
+      return result[0] ? toDevice(result[0]) : null;
+    },
+    async findDeviceByEnrollmentId(enrollmentId) {
+      const result = await db.select().from(devices).where(eq(devices.enrollmentId, enrollmentId)).limit(1);
+      return result[0] ? toDevice(result[0]) : null;
+    },
+    async listDevices(filter) {
+      const limit = filter?.limit ?? 100;
+      const offset = filter?.offset ?? 0;
+      let query = db.select().from(devices);
+      const conditions = [];
+      if (filter?.status) {
+        if (Array.isArray(filter.status)) {
+          conditions.push(inArray(devices.status, filter.status));
+        } else {
+          conditions.push(eq(devices.status, filter.status));
+        }
+      }
+      if (filter?.policyId) {
+        conditions.push(eq(devices.policyId, filter.policyId));
+      }
+      if (filter?.search) {
+        const searchPattern = `%${filter.search}%`;
+        conditions.push(
+          or(
+            like(devices.model, searchPattern),
+            like(devices.manufacturer, searchPattern),
+            like(devices.enrollmentId, searchPattern),
+            like(devices.serialNumber, searchPattern)
+          )
+        );
+      }
+      if (conditions.length > 0) {
+        query = query.where(and(...conditions));
+      }
+      const countResult = await db.select({ count: sql`count(*)` }).from(devices).where(conditions.length > 0 ? and(...conditions) : void 0);
+      const total = Number(countResult[0]?.count ?? 0);
+      const result = await query.orderBy(desc(devices.createdAt)).limit(limit).offset(offset);
+      return {
+        devices: result.map(toDevice),
+        total,
+        limit,
+        offset
+      };
+    },
+    async createDevice(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const deviceData = {
+        id,
+        enrollmentId: data.enrollmentId,
+        externalId: data.externalId ?? null,
+        status: "pending",
+        model: data.model ?? null,
+        manufacturer: data.manufacturer ?? null,
+        osVersion: data.osVersion ?? null,
+        serialNumber: data.serialNumber ?? null,
+        imei: data.imei ?? null,
+        macAddress: data.macAddress ?? null,
+        androidId: data.androidId ?? null,
+        policyId: data.policyId ?? null,
+        tags: data.tags ?? null,
+        metadata: data.metadata ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(devices).values(deviceData);
+      return this.findDevice(id);
+    },
+    async updateDevice(id, data) {
+      const updateData = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (data.externalId !== void 0) updateData.externalId = data.externalId;
+      if (data.status !== void 0) updateData.status = data.status;
+      if (data.policyId !== void 0) updateData.policyId = data.policyId;
+      if (data.model !== void 0) updateData.model = data.model;
+      if (data.manufacturer !== void 0)
+        updateData.manufacturer = data.manufacturer;
+      if (data.osVersion !== void 0) updateData.osVersion = data.osVersion;
+      if (data.batteryLevel !== void 0)
+        updateData.batteryLevel = data.batteryLevel;
+      if (data.storageUsed !== void 0)
+        updateData.storageUsed = data.storageUsed;
+      if (data.storageTotal !== void 0)
+        updateData.storageTotal = data.storageTotal;
+      if (data.lastHeartbeat !== void 0)
+        updateData.lastHeartbeat = data.lastHeartbeat;
+      if (data.lastSync !== void 0) updateData.lastSync = data.lastSync;
+      if (data.installedApps !== void 0)
+        updateData.installedApps = data.installedApps;
+      if (data.tags !== void 0) updateData.tags = data.tags;
+      if (data.metadata !== void 0) updateData.metadata = data.metadata;
+      if (data.location) {
+        updateData.latitude = data.location.latitude.toString();
+        updateData.longitude = data.location.longitude.toString();
+        updateData.locationTimestamp = data.location.timestamp;
+      }
+      await db.update(devices).set(updateData).where(eq(devices.id, id));
+      return this.findDevice(id);
+    },
+    async deleteDevice(id) {
+      await db.delete(devices).where(eq(devices.id, id));
+    },
+    async countDevices(filter) {
+      const result = await this.listDevices({ ...filter, limit: 0 });
+      return result.total;
+    },
+    // ============================================
+    // Policy Methods
+    // ============================================
+    async findPolicy(id) {
+      const result = await db.select().from(policies).where(eq(policies.id, id)).limit(1);
+      return result[0] ? toPolicy(result[0]) : null;
+    },
+    async findDefaultPolicy() {
+      const result = await db.select().from(policies).where(eq(policies.isDefault, true)).limit(1);
+      return result[0] ? toPolicy(result[0]) : null;
+    },
+    async listPolicies() {
+      const result = await db.select().from(policies).orderBy(desc(policies.createdAt));
+      return result.map(toPolicy);
+    },
+    async createPolicy(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const policyData = {
+        id,
+        name: data.name,
+        description: data.description ?? null,
+        isDefault: data.isDefault ?? false,
+        settings: data.settings,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(policies).values(policyData);
+      return this.findPolicy(id);
+    },
+    async updatePolicy(id, data) {
+      const updateData = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (data.name !== void 0) updateData.name = data.name;
+      if (data.description !== void 0)
+        updateData.description = data.description;
+      if (data.isDefault !== void 0) updateData.isDefault = data.isDefault;
+      if (data.settings !== void 0) updateData.settings = data.settings;
+      await db.update(policies).set(updateData).where(eq(policies.id, id));
+      return this.findPolicy(id);
+    },
+    async deletePolicy(id) {
+      await db.delete(policies).where(eq(policies.id, id));
+    },
+    // ============================================
+    // Application Methods
+    // ============================================
+    async findApplication(id) {
+      const result = await db.select().from(applications).where(eq(applications.id, id)).limit(1);
+      return result[0] ? toApplication(result[0]) : null;
+    },
+    async findApplicationByPackage(packageName, version) {
+      let query = db.select().from(applications).where(eq(applications.packageName, packageName));
+      if (version) {
+        query = query.where(eq(applications.version, version));
+      }
+      const result = await query.orderBy(desc(applications.versionCode)).limit(1);
+      return result[0] ? toApplication(result[0]) : null;
+    },
+    async listApplications(activeOnly) {
+      let query = db.select().from(applications);
+      if (activeOnly) {
+        query = query.where(eq(applications.isActive, true));
+      }
+      const result = await query.orderBy(desc(applications.createdAt));
+      return result.map(toApplication);
+    },
+    async createApplication(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const appData = {
+        id,
+        name: data.name,
+        packageName: data.packageName,
+        version: data.version,
+        versionCode: data.versionCode,
+        url: data.url,
+        hash: data.hash ?? null,
+        size: data.size ?? null,
+        minSdkVersion: data.minSdkVersion ?? null,
+        showIcon: data.showIcon ?? true,
+        runAfterInstall: data.runAfterInstall ?? false,
+        runAtBoot: data.runAtBoot ?? false,
+        isSystem: data.isSystem ?? false,
+        isActive: true,
+        metadata: data.metadata ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(applications).values(appData);
+      return this.findApplication(id);
+    },
+    async updateApplication(id, data) {
+      const updateData = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (data.name !== void 0) updateData.name = data.name;
+      if (data.version !== void 0) updateData.version = data.version;
+      if (data.versionCode !== void 0)
+        updateData.versionCode = data.versionCode;
+      if (data.url !== void 0) updateData.url = data.url;
+      if (data.hash !== void 0) updateData.hash = data.hash;
+      if (data.size !== void 0) updateData.size = data.size;
+      if (data.minSdkVersion !== void 0)
+        updateData.minSdkVersion = data.minSdkVersion;
+      if (data.showIcon !== void 0) updateData.showIcon = data.showIcon;
+      if (data.runAfterInstall !== void 0)
+        updateData.runAfterInstall = data.runAfterInstall;
+      if (data.runAtBoot !== void 0) updateData.runAtBoot = data.runAtBoot;
+      if (data.isActive !== void 0) updateData.isActive = data.isActive;
+      if (data.metadata !== void 0) updateData.metadata = data.metadata;
+      await db.update(applications).set(updateData).where(eq(applications.id, id));
+      return this.findApplication(id);
+    },
+    async deleteApplication(id) {
+      await db.delete(applications).where(eq(applications.id, id));
+    },
+    // ============================================
+    // Command Methods
+    // ============================================
+    async findCommand(id) {
+      const result = await db.select().from(commands).where(eq(commands.id, id)).limit(1);
+      return result[0] ? toCommand(result[0]) : null;
+    },
+    async listCommands(filter) {
+      let query = db.select().from(commands);
+      const conditions = [];
+      if (filter?.deviceId) {
+        conditions.push(eq(commands.deviceId, filter.deviceId));
+      }
+      if (filter?.status) {
+        if (Array.isArray(filter.status)) {
+          conditions.push(inArray(commands.status, filter.status));
+        } else {
+          conditions.push(eq(commands.status, filter.status));
+        }
+      }
+      if (filter?.type) {
+        if (Array.isArray(filter.type)) {
+          conditions.push(inArray(commands.type, filter.type));
+        } else {
+          conditions.push(eq(commands.type, filter.type));
+        }
+      }
+      if (conditions.length > 0) {
+        query = query.where(and(...conditions));
+      }
+      const limit = filter?.limit ?? 100;
+      const offset = filter?.offset ?? 0;
+      const result = await query.orderBy(desc(commands.createdAt)).limit(limit).offset(offset);
+      return result.map(toCommand);
+    },
+    async createCommand(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const commandData = {
+        id,
+        deviceId: data.deviceId,
+        type: data.type,
+        payload: data.payload ?? null,
+        status: "pending",
+        createdAt: now
+      };
+      await db.insert(commands).values(commandData);
+      return this.findCommand(id);
+    },
+    async updateCommand(id, data) {
+      const updateData = {};
+      if (data.status !== void 0) updateData.status = data.status;
+      if (data.result !== void 0) updateData.result = data.result;
+      if (data.error !== void 0) updateData.error = data.error;
+      if (data.sentAt !== void 0) updateData.sentAt = data.sentAt;
+      if (data.acknowledgedAt !== void 0)
+        updateData.acknowledgedAt = data.acknowledgedAt;
+      if (data.completedAt !== void 0)
+        updateData.completedAt = data.completedAt;
+      await db.update(commands).set(updateData).where(eq(commands.id, id));
+      return this.findCommand(id);
+    },
+    async getPendingCommands(deviceId) {
+      return this.listCommands({
+        deviceId,
+        status: ["pending", "sent"]
+      });
+    },
+    // ============================================
+    // Event Methods
+    // ============================================
+    async createEvent(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const eventData = {
+        id,
+        deviceId: data.deviceId,
+        type: data.type,
+        payload: data.payload,
+        createdAt: now
+      };
+      await db.insert(events).values(eventData);
+      return {
+        ...eventData,
+        createdAt: now
+      };
+    },
+    async listEvents(filter) {
+      let query = db.select().from(events);
+      const conditions = [];
+      if (filter?.deviceId) {
+        conditions.push(eq(events.deviceId, filter.deviceId));
+      }
+      if (filter?.type) {
+        if (Array.isArray(filter.type)) {
+          conditions.push(inArray(events.type, filter.type));
+        } else {
+          conditions.push(eq(events.type, filter.type));
+        }
+      }
+      if (conditions.length > 0) {
+        query = query.where(and(...conditions));
+      }
+      const limit = filter?.limit ?? 100;
+      const offset = filter?.offset ?? 0;
+      const result = await query.orderBy(desc(events.createdAt)).limit(limit).offset(offset);
+      return result.map(toEvent);
+    },
+    // ============================================
+    // Group Methods
+    // ============================================
+    async findGroup(id) {
+      const result = await db.select().from(groups).where(eq(groups.id, id)).limit(1);
+      return result[0] ? toGroup(result[0]) : null;
+    },
+    async listGroups() {
+      const result = await db.select().from(groups).orderBy(groups.name);
+      return result.map(toGroup);
+    },
+    async createGroup(data) {
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const groupData = {
+        id,
+        name: data.name,
+        description: data.description ?? null,
+        policyId: data.policyId ?? null,
+        parentId: data.parentId ?? null,
+        metadata: data.metadata ?? null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(groups).values(groupData);
+      return this.findGroup(id);
+    },
+    async updateGroup(id, data) {
+      const updateData = {
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (data.name !== void 0) updateData.name = data.name;
+      if (data.description !== void 0)
+        updateData.description = data.description;
+      if (data.policyId !== void 0) updateData.policyId = data.policyId;
+      if (data.parentId !== void 0) updateData.parentId = data.parentId;
+      if (data.metadata !== void 0) updateData.metadata = data.metadata;
+      await db.update(groups).set(updateData).where(eq(groups.id, id));
+      return this.findGroup(id);
+    },
+    async deleteGroup(id) {
+      await db.delete(groups).where(eq(groups.id, id));
+    },
+    async listDevicesInGroup(groupId) {
+      const result = await db.select({ device: devices }).from(deviceGroups).innerJoin(devices, eq(deviceGroups.deviceId, devices.id)).where(eq(deviceGroups.groupId, groupId));
+      return result.map(
+        (r) => toDevice(r.device)
+      );
+    },
+    async addDeviceToGroup(deviceId, groupId) {
+      await db.insert(deviceGroups).values({
+        deviceId,
+        groupId,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    },
+    async removeDeviceFromGroup(deviceId, groupId) {
+      await db.delete(deviceGroups).where(
+        and(
+          eq(deviceGroups.deviceId, deviceId),
+          eq(deviceGroups.groupId, groupId)
+        )
+      );
+    },
+    async getDeviceGroups(deviceId) {
+      const result = await db.select({ group: groups }).from(deviceGroups).innerJoin(groups, eq(deviceGroups.groupId, groups.id)).where(eq(deviceGroups.deviceId, deviceId));
+      return result.map(
+        (r) => toGroup(r.group)
+      );
+    },
+    // ============================================
+    // Push Token Methods
+    // ============================================
+    async findPushToken(deviceId, provider) {
+      const result = await db.select().from(pushTokens).where(
+        and(
+          eq(pushTokens.deviceId, deviceId),
+          eq(pushTokens.provider, provider)
+        )
+      ).limit(1);
+      return result[0] ? toPushToken(result[0]) : null;
+    },
+    async upsertPushToken(data) {
+      const existing = await this.findPushToken(data.deviceId, data.provider);
+      const now = /* @__PURE__ */ new Date();
+      if (existing) {
+        await db.update(pushTokens).set({
+          token: data.token,
+          isActive: true,
+          updatedAt: now
+        }).where(eq(pushTokens.id, existing.id));
+        return this.findPushToken(data.deviceId, data.provider);
+      }
+      const id = generateId();
+      await db.insert(pushTokens).values({
+        id,
+        deviceId: data.deviceId,
+        provider: data.provider,
+        token: data.token,
+        isActive: true,
+        createdAt: now,
+        updatedAt: now
+      });
+      return this.findPushToken(data.deviceId, data.provider);
+    },
+    async deletePushToken(deviceId, provider) {
+      if (provider) {
+        await db.delete(pushTokens).where(
+          and(
+            eq(pushTokens.deviceId, deviceId),
+            eq(pushTokens.provider, provider)
+          )
+        );
+      } else {
+        await db.delete(pushTokens).where(eq(pushTokens.deviceId, deviceId));
+      }
+    },
+    // ============================================
+    // Transaction Support
+    // ============================================
+    async transaction(fn) {
+      return db.transaction(async () => {
+        return fn();
+      });
+    }
+  };
+}
+export {
+  DEFAULT_TABLE_PREFIX,
+  drizzleAdapter
+};
+//# sourceMappingURL=index.js.map