@hot-updater/postgres 0.1.5 → 0.2.0

package/dist/index.cjs

@@ -1,122 +1,124 @@
 "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/index.ts
-var src_exports = {};
-__export(src_exports, {
-  postgres: () => postgres
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    postgres: ()=>postgres
 });
-module.exports = __toCommonJS(src_exports);
-
-// src/postgres.ts
-var import_kysely = require("kysely");
-var import_pg = require("pg");
-var postgres = (config, hooks) => (_) => {
-  const pool = new import_pg.Pool(config);
-  const dialect = new import_kysely.PostgresDialect({
-    pool
-  });
-  const db = new import_kysely.Kysely({
-    dialect
-  });
-  let bundles = [];
-  return {
-    async onUnmount() {
-      await pool.end();
-    },
-    async commitBundle() {
-      await db.transaction().execute(async (tx) => {
-        for (const bundle of bundles) {
-          tx.insertInto("bundles").values({
-            id: bundle.id,
-            enabled: bundle.enabled,
-            file: bundle.file,
-            force_update: bundle.forceUpdate,
-            hash: bundle.hash,
-            message: bundle.message,
-            platform: bundle.platform,
-            target_version: bundle.targetVersion
-          }).onConflict(
-            (oc) => oc.column("id").doUpdateSet({
-              enabled: bundle.enabled,
-              file: bundle.file,
-              force_update: bundle.forceUpdate,
-              hash: bundle.hash,
-              message: bundle.message,
-              platform: bundle.platform,
-              target_version: bundle.targetVersion
-            })
-          ).execute();
-        }
-      });
-      hooks?.onDatabaseUpdated?.();
-    },
-    async updateBundle(targetBundleId, newBundle) {
-      bundles = await this.getBundles();
-      const targetIndex = bundles.findIndex((u) => u.id === targetBundleId);
-      if (targetIndex === -1) {
-        throw new Error("target bundle version not found");
-      }
-      Object.assign(bundles[targetIndex], newBundle);
-    },
-    async appendBundle(inputBundle) {
-      bundles = await this.getBundles();
-      bundles.unshift(inputBundle);
-    },
-    async setBundles(inputBundles) {
-      bundles = inputBundles;
-    },
-    async getBundleById(bundleId) {
-      const data = await db.selectFrom("bundles").selectAll().where("id", "=", bundleId).executeTakeFirst();
-      if (!data) {
-        return null;
-      }
-      return {
-        enabled: data.enabled,
-        file: data.file,
-        forceUpdate: data.force_update,
-        hash: data.hash,
-        id: data.id,
-        message: data.message,
-        platform: data.platform,
-        targetVersion: data.target_version
-      };
-    },
-    async getBundles(refresh = false) {
-      if (bundles.length > 0 && !refresh) {
-        return bundles;
-      }
-      const data = await db.selectFrom("bundles").selectAll().execute();
-      return data.map((bundle) => ({
-        enabled: bundle.enabled,
-        file: bundle.file,
-        forceUpdate: bundle.force_update,
-        hash: bundle.hash,
-        id: bundle.id,
-        message: bundle.message,
-        platform: bundle.platform,
-        targetVersion: bundle.target_version
-      }));
-    }
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  postgres
+const external_kysely_namespaceObject = require("kysely");
+const external_pg_namespaceObject = require("pg");
+const postgres = (config, hooks)=>(_)=>{
+        const pool = new external_pg_namespaceObject.Pool(config);
+        const dialect = new external_kysely_namespaceObject.PostgresDialect({
+            pool
+        });
+        const db = new external_kysely_namespaceObject.Kysely({
+            dialect
+        });
+        let bundles = [];
+        let isUnmount = false;
+        return {
+            name: "postgres",
+            async onUnmount () {
+                if (isUnmount) return;
+                isUnmount = true;
+                await pool.end();
+            },
+            async commitBundle () {
+                await db.transaction().execute(async (tx)=>{
+                    for (const bundle of bundles)await tx.insertInto("bundles").values({
+                        id: bundle.id,
+                        enabled: bundle.enabled,
+                        file_url: bundle.fileUrl,
+                        force_update: bundle.forceUpdate,
+                        file_hash: bundle.fileHash,
+                        git_commit_hash: bundle.gitCommitHash,
+                        message: bundle.message,
+                        platform: bundle.platform,
+                        target_app_version: bundle.targetAppVersion
+                    }).onConflict((oc)=>oc.column("id").doUpdateSet({
+                            enabled: bundle.enabled,
+                            file_url: bundle.fileUrl,
+                            force_update: bundle.forceUpdate,
+                            file_hash: bundle.fileHash,
+                            git_commit_hash: bundle.gitCommitHash,
+                            message: bundle.message,
+                            platform: bundle.platform,
+                            target_app_version: bundle.targetAppVersion
+                        })).execute();
+                });
+                hooks?.onDatabaseUpdated?.();
+            },
+            async updateBundle (targetBundleId, newBundle) {
+                bundles = await this.getBundles();
+                const targetIndex = bundles.findIndex((u)=>u.id === targetBundleId);
+                if (-1 === targetIndex) throw new Error("target bundle version not found");
+                Object.assign(bundles[targetIndex], newBundle);
+            },
+            async appendBundle (inputBundle) {
+                bundles = await this.getBundles();
+                bundles.unshift(inputBundle);
+            },
+            async setBundles (inputBundles) {
+                bundles = inputBundles;
+            },
+            async getBundleById (bundleId) {
+                const data = await db.selectFrom("bundles").selectAll().where("id", "=", bundleId).executeTakeFirst();
+                if (!data) return null;
+                return {
+                    enabled: data.enabled,
+                    fileUrl: data.file_url,
+                    forceUpdate: data.force_update,
+                    fileHash: data.file_hash,
+                    gitCommitHash: data.git_commit_hash,
+                    id: data.id,
+                    message: data.message,
+                    platform: data.platform,
+                    targetAppVersion: data.target_app_version
+                };
+            },
+            async getBundles (refresh = false) {
+                if (bundles.length > 0 && !refresh) return bundles;
+                const data = await db.selectFrom("bundles").orderBy("id", "desc").selectAll().execute();
+                return data.map((bundle)=>({
+                        enabled: bundle.enabled,
+                        fileUrl: bundle.file_url,
+                        forceUpdate: bundle.force_update,
+                        fileHash: bundle.file_hash,
+                        gitCommitHash: bundle.git_commit_hash,
+                        id: bundle.id,
+                        message: bundle.message,
+                        platform: bundle.platform,
+                        targetAppVersion: bundle.target_app_version
+                    }));
+            }
+        };
+    };
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
 });

package/dist/index.d.ts

@@ -1,8 +1 @@
-import { DatabasePluginHooks, BasePluginArgs, DatabasePlugin } from '@hot-updater/plugin-core';
-import { PoolConfig } from 'pg';
-
-interface PostgresConfig extends PoolConfig {
-}
-declare const postgres: (config: PostgresConfig, hooks?: DatabasePluginHooks) => (_: BasePluginArgs) => DatabasePlugin;
-
-export { type PostgresConfig, postgres };
+export * from "./postgres";

package/dist/index.js

@@ -1,95 +1,90 @@
-// src/postgres.ts
-import { Kysely, PostgresDialect } from "kysely";
-import { Pool } from "pg";
-var postgres = (config, hooks) => (_) => {
-  const pool = new Pool(config);
-  const dialect = new PostgresDialect({
-    pool
-  });
-  const db = new Kysely({
-    dialect
-  });
-  let bundles = [];
-  return {
-    async onUnmount() {
-      await pool.end();
-    },
-    async commitBundle() {
-      await db.transaction().execute(async (tx) => {
-        for (const bundle of bundles) {
-          tx.insertInto("bundles").values({
-            id: bundle.id,
-            enabled: bundle.enabled,
-            file: bundle.file,
-            force_update: bundle.forceUpdate,
-            hash: bundle.hash,
-            message: bundle.message,
-            platform: bundle.platform,
-            target_version: bundle.targetVersion
-          }).onConflict(
-            (oc) => oc.column("id").doUpdateSet({
-              enabled: bundle.enabled,
-              file: bundle.file,
-              force_update: bundle.forceUpdate,
-              hash: bundle.hash,
-              message: bundle.message,
-              platform: bundle.platform,
-              target_version: bundle.targetVersion
-            })
-          ).execute();
-        }
-      });
-      hooks?.onDatabaseUpdated?.();
-    },
-    async updateBundle(targetBundleId, newBundle) {
-      bundles = await this.getBundles();
-      const targetIndex = bundles.findIndex((u) => u.id === targetBundleId);
-      if (targetIndex === -1) {
-        throw new Error("target bundle version not found");
-      }
-      Object.assign(bundles[targetIndex], newBundle);
-    },
-    async appendBundle(inputBundle) {
-      bundles = await this.getBundles();
-      bundles.unshift(inputBundle);
-    },
-    async setBundles(inputBundles) {
-      bundles = inputBundles;
-    },
-    async getBundleById(bundleId) {
-      const data = await db.selectFrom("bundles").selectAll().where("id", "=", bundleId).executeTakeFirst();
-      if (!data) {
-        return null;
-      }
-      return {
-        enabled: data.enabled,
-        file: data.file,
-        forceUpdate: data.force_update,
-        hash: data.hash,
-        id: data.id,
-        message: data.message,
-        platform: data.platform,
-        targetVersion: data.target_version
-      };
-    },
-    async getBundles(refresh = false) {
-      if (bundles.length > 0 && !refresh) {
-        return bundles;
-      }
-      const data = await db.selectFrom("bundles").selectAll().execute();
-      return data.map((bundle) => ({
-        enabled: bundle.enabled,
-        file: bundle.file,
-        forceUpdate: bundle.force_update,
-        hash: bundle.hash,
-        id: bundle.id,
-        message: bundle.message,
-        platform: bundle.platform,
-        targetVersion: bundle.target_version
-      }));
-    }
-  };
-};
-export {
-  postgres
-};
+import * as __WEBPACK_EXTERNAL_MODULE_kysely__ from "kysely";
+import * as __WEBPACK_EXTERNAL_MODULE_pg__ from "pg";
+const postgres = (config, hooks)=>(_)=>{
+        const pool = new __WEBPACK_EXTERNAL_MODULE_pg__.Pool(config);
+        const dialect = new __WEBPACK_EXTERNAL_MODULE_kysely__.PostgresDialect({
+            pool
+        });
+        const db = new __WEBPACK_EXTERNAL_MODULE_kysely__.Kysely({
+            dialect
+        });
+        let bundles = [];
+        let isUnmount = false;
+        return {
+            name: "postgres",
+            async onUnmount () {
+                if (isUnmount) return;
+                isUnmount = true;
+                await pool.end();
+            },
+            async commitBundle () {
+                await db.transaction().execute(async (tx)=>{
+                    for (const bundle of bundles)await tx.insertInto("bundles").values({
+                        id: bundle.id,
+                        enabled: bundle.enabled,
+                        file_url: bundle.fileUrl,
+                        force_update: bundle.forceUpdate,
+                        file_hash: bundle.fileHash,
+                        git_commit_hash: bundle.gitCommitHash,
+                        message: bundle.message,
+                        platform: bundle.platform,
+                        target_app_version: bundle.targetAppVersion
+                    }).onConflict((oc)=>oc.column("id").doUpdateSet({
+                            enabled: bundle.enabled,
+                            file_url: bundle.fileUrl,
+                            force_update: bundle.forceUpdate,
+                            file_hash: bundle.fileHash,
+                            git_commit_hash: bundle.gitCommitHash,
+                            message: bundle.message,
+                            platform: bundle.platform,
+                            target_app_version: bundle.targetAppVersion
+                        })).execute();
+                });
+                hooks?.onDatabaseUpdated?.();
+            },
+            async updateBundle (targetBundleId, newBundle) {
+                bundles = await this.getBundles();
+                const targetIndex = bundles.findIndex((u)=>u.id === targetBundleId);
+                if (-1 === targetIndex) throw new Error("target bundle version not found");
+                Object.assign(bundles[targetIndex], newBundle);
+            },
+            async appendBundle (inputBundle) {
+                bundles = await this.getBundles();
+                bundles.unshift(inputBundle);
+            },
+            async setBundles (inputBundles) {
+                bundles = inputBundles;
+            },
+            async getBundleById (bundleId) {
+                const data = await db.selectFrom("bundles").selectAll().where("id", "=", bundleId).executeTakeFirst();
+                if (!data) return null;
+                return {
+                    enabled: data.enabled,
+                    fileUrl: data.file_url,
+                    forceUpdate: data.force_update,
+                    fileHash: data.file_hash,
+                    gitCommitHash: data.git_commit_hash,
+                    id: data.id,
+                    message: data.message,
+                    platform: data.platform,
+                    targetAppVersion: data.target_app_version
+                };
+            },
+            async getBundles (refresh = false) {
+                if (bundles.length > 0 && !refresh) return bundles;
+                const data = await db.selectFrom("bundles").orderBy("id", "desc").selectAll().execute();
+                return data.map((bundle)=>({
+                        enabled: bundle.enabled,
+                        fileUrl: bundle.file_url,
+                        forceUpdate: bundle.force_update,
+                        fileHash: bundle.file_hash,
+                        gitCommitHash: bundle.git_commit_hash,
+                        id: bundle.id,
+                        message: bundle.message,
+                        platform: bundle.platform,
+                        targetAppVersion: bundle.target_app_version
+                    }));
+            }
+        };
+    };
+export { postgres };

package/dist/postgres.d.ts

@@ -0,0 +1,5 @@
+import type { BasePluginArgs, DatabasePlugin, DatabasePluginHooks } from "@hot-updater/plugin-core";
+import { type PoolConfig } from "pg";
+export interface PostgresConfig extends PoolConfig {
+}
+export declare const postgres: (config: PostgresConfig, hooks?: DatabasePluginHooks) => (_: BasePluginArgs) => DatabasePlugin;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import type { Bundle } from "@hot-updater/core";
+type SnakeCase<S extends string> = S extends `${infer T}${infer U}` ? `${T extends Capitalize<T> ? "_" : ""}${Lowercase<T>}${SnakeCase<U>}` : S;
+type SnakeKeyObject<T> = T extends Record<string, any> ? {
+    [K in keyof T as SnakeCase<Extract<K, string>>]: T[K] extends object ? SnakeKeyObject<T[K]> : T[K];
+} : T;
+export type BundlesTable = SnakeKeyObject<Bundle>;
+export interface Database {
+    bundles: BundlesTable;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hot-updater/postgres",
   "type": "module",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -18,18 +18,22 @@
   },
   "files": [
     "dist",
+    "sql",
     "package.json"
   ],
   "dependencies": {
-    "@hot-updater/plugin-core": "0.1.5",
-    "kysely": "^0.27.4",
+    "@hot-updater/core": "0.2.0",
+    "@hot-updater/plugin-core": "0.2.0",
+    "kysely": "^0.27.5",
     "pg": "^8.13.1"
   },
   "devDependencies": {
-    "@types/pg": "^8.11.10"
+    "@electric-sql/pglite": "^0.2.15",
+    "@types/pg": "^8.11.10",
+    "camelcase-keys": "^9.1.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "rslib build",
     "test:type": "tsc --noEmit"
   }
 }

package/sql/bundles.sql

@@ -0,0 +1,13 @@
+CREATE TYPE platforms AS ENUM ('ios', 'android');
+
+CREATE TABLE bundles (
+    id uuid PRIMARY KEY,
+    platform platforms NOT NULL,
+    target_app_version text NOT NULL,
+    force_update boolean NOT NULL,
+    enabled boolean NOT NULL,
+    file_url text NOT NULL,
+    file_hash text NOT NULL,
+    git_commit_hash text,
+    message text
+);

package/sql/get_update_info.sql

@@ -0,0 +1,79 @@
+CREATE OR REPLACE FUNCTION get_update_info (
+    app_platform   platforms,
+    app_version text,
+    bundle_id  uuid
+)
+RETURNS TABLE (
+    id            uuid,
+    force_update  boolean,
+    file_url      text,
+    file_hash     text,
+    status        text
+)
+LANGUAGE plpgsql
+AS
+$$
+DECLARE
+    NIL_UUID CONSTANT uuid := '00000000-0000-0000-0000-000000000000';
+BEGIN
+    RETURN QUERY
+    WITH rollback_candidate AS (
+        SELECT
+            b.id,
+            -- If status is 'ROLLBACK', force_update is always TRUE
+            TRUE AS force_update,
+            b.file_url,
+            b.file_hash,
+            'ROLLBACK' AS status
+        FROM bundles b
+        WHERE b.enabled = TRUE
+          AND b.platform = app_platform
+          AND b.id < bundle_id
+        ORDER BY b.id DESC
+        LIMIT 1
+    ),
+    update_candidate AS (
+        SELECT
+            b.id,
+            b.force_update,
+            b.file_url,
+            b.file_hash,
+            'UPDATE' AS status
+        FROM bundles b
+        WHERE b.enabled = TRUE
+          AND b.platform = app_platform
+          AND b.id >= bundle_id
+          AND semver_satisfies(b.target_app_version, app_version)
+        ORDER BY b.id DESC
+        LIMIT 1
+    ),
+    final_result AS (
+        SELECT *
+        FROM update_candidate
+
+        UNION ALL
+
+        SELECT *
+        FROM rollback_candidate
+        WHERE NOT EXISTS (SELECT 1 FROM update_candidate)
+    )
+    SELECT *
+    FROM final_result WHERE final_result.id != bundle_id
+
+    UNION ALL
+    /*
+      When there are no final results and bundle_id != NIL_UUID,
+      add one fallback row.
+      This fallback row is also ROLLBACK so forceUpdate = TRUE.
+    */
+    SELECT
+        NIL_UUID      AS id,
+        TRUE          AS force_update,  -- Always TRUE
+        NULL          AS file_url,
+        NULL          AS file_hash,
+        'ROLLBACK'    AS status
+    WHERE (SELECT COUNT(*) FROM final_result) = 0
+      AND bundle_id != NIL_UUID;
+
+END;
+$$;

package/sql/get_update_info.test.ts

@@ -0,0 +1,74 @@
+import { PGlite } from "@electric-sql/pglite";
+import type { Bundle, GetBundlesArgs, UpdateInfo } from "@hot-updater/core";
+import { setupGetUpdateInfoTestSuite } from "@hot-updater/core/test-utils";
+import camelcaseKeys from "camelcase-keys";
+import { afterAll, beforeEach, describe } from "vitest";
+import { prepareSql } from "./prepareSql";
+
+const createInsertBundleQuery = (bundle: Bundle) => {
+  return `
+    INSERT INTO bundles (
+      id, file_url, file_hash, platform, target_app_version,
+      force_update, enabled, git_commit_hash, message
+    ) VALUES (
+      '${bundle.id}',
+      '${bundle.fileUrl}',
+      '${bundle.fileHash}',
+      '${bundle.platform}',
+      '${bundle.targetAppVersion}',
+      ${bundle.forceUpdate},
+      ${bundle.enabled},
+      ${bundle.gitCommitHash ? `'${bundle.gitCommitHash}'` : "null"},
+      ${bundle.message ? `'${bundle.message}'` : "null"}
+    );
+  `;
+};
+
+const createGetUpdateInfo =
+  (db: PGlite) =>
+  async (
+    bundles: Bundle[],
+    { appVersion, bundleId, platform }: GetBundlesArgs,
+  ): Promise<UpdateInfo | null> => {
+    await db.exec(createInsertBundleQuerys(bundles));
+
+    const result = await db.query<{
+      id: string;
+      force_update: boolean;
+      file_url: string;
+      file_hash: string;
+      status: string;
+    }>(
+      `
+      SELECT * FROM get_update_info('${platform}', '${appVersion}', '${bundleId}')
+    `,
+    );
+
+    return result.rows[0]
+      ? (camelcaseKeys(result.rows[0]) as UpdateInfo)
+      : null;
+  };
+
+const createInsertBundleQuerys = (bundles: Bundle[]) => {
+  return bundles.map(createInsertBundleQuery).join("\n");
+};
+
+const db = new PGlite();
+
+const sql = await prepareSql();
+await db.exec(sql);
+const getUpdateInfo = createGetUpdateInfo(db);
+
+describe("getUpdateInfo", () => {
+  beforeEach(async () => {
+    await db.exec("DELETE FROM bundles");
+  });
+
+  afterAll(async () => {
+    await db.close();
+  });
+
+  setupGetUpdateInfoTestSuite({
+    getUpdateInfo: getUpdateInfo,
+  });
+});

package/sql/prepareSql.ts

@@ -0,0 +1,11 @@
+import path from "path";
+import fs from "fs/promises";
+
+export const prepareSql = async () => {
+  const files = await fs.readdir(__dirname);
+  const sqlFiles = files.filter((file) => file.endsWith(".sql"));
+  const contents = await Promise.all(
+    sqlFiles.map((file) => fs.readFile(path.join(__dirname, file), "utf-8")),
+  );
+  return contents.join("\n");
+};

package/sql/semver.sql

@@ -0,0 +1,97 @@
+CREATE OR REPLACE FUNCTION semver_satisfies(range_expression TEXT, version TEXT)
+RETURNS BOOLEAN AS $$
+DECLARE
+    version_parts TEXT[];
+    version_major INT;
+    version_minor INT;
+    version_patch INT;
+    satisfies BOOLEAN := FALSE;
+BEGIN
+    -- Split the version into major, minor, and patch
+    version_parts := string_to_array(version, '.');
+    version_major := version_parts[1]::INT;
+    version_minor := version_parts[2]::INT;
+    version_patch := version_parts[3]::INT;
+
+    -- Parse range expression and evaluate
+    IF range_expression ~ '^\d+\.\d+\.\d+$' THEN
+        -- Exact match
+        satisfies := (range_expression = version);
+
+    ELSIF range_expression = '*' THEN
+        -- Matches any version
+        satisfies := TRUE;
+
+    ELSIF range_expression ~ '^\d+\.x\.x$' THEN
+        -- Matches major.x.x
+        DECLARE
+            major_range INT := split_part(range_expression, '.', 1)::INT;
+        BEGIN
+            satisfies := (version_major = major_range);
+        END;
+
+    ELSIF range_expression ~ '^\d+\.\d+\.x$' THEN
+        -- Matches major.minor.x
+        DECLARE
+            major_range INT := split_part(range_expression, '.', 1)::INT;
+            minor_range INT := split_part(range_expression, '.', 2)::INT;
+        BEGIN
+            satisfies := (version_major = major_range AND version_minor = minor_range);
+        END;
+
+    ELSIF range_expression ~ '^\d+\.\d+$' THEN
+        -- Matches major.minor
+        DECLARE
+            major_range INT := split_part(range_expression, '.', 1)::INT;
+            minor_range INT := split_part(range_expression, '.', 2)::INT;
+        BEGIN
+            satisfies := (version_major = major_range AND version_minor = minor_range);
+        END;
+
+    ELSIF range_expression ~ '^\d+\.\d+\.\d+ - \d+\.\d+\.\d+$' THEN
+        -- Matches range e.g., 1.2.3 - 1.2.7
+        DECLARE
+            lower_bound TEXT := split_part(range_expression, ' - ', 1);
+            upper_bound TEXT := split_part(range_expression, ' - ', 2);
+        BEGIN
+            satisfies := (version >= lower_bound AND version <= upper_bound);
+        END;
+
+    ELSIF range_expression ~ '^>=\d+\.\d+\.\d+ <\d+\.\d+\.\d+$' THEN
+        -- Matches range with inequalities
+        DECLARE
+            lower_bound TEXT := regexp_replace(range_expression, '>=([\d\.]+) <.*', '\1');
+            upper_bound TEXT := regexp_replace(range_expression, '.*<([\d\.]+)', '\1');
+        BEGIN
+            satisfies := (version >= lower_bound AND version < upper_bound);
+        END;
+
+    ELSIF range_expression ~ '^~\d+\.\d+\.\d+$' THEN
+        -- Matches ~1.2.3 (>=1.2.3 <1.3.0)
+        DECLARE
+            lower_bound TEXT := regexp_replace(range_expression, '~', '');
+            upper_bound_major INT := split_part(lower_bound, '.', 1)::INT;
+            upper_bound_minor INT := split_part(lower_bound, '.', 2)::INT + 1;
+            upper_bound TEXT := upper_bound_major || '.' || upper_bound_minor || '.0';
+        BEGIN
+            satisfies := (version >= lower_bound AND version < upper_bound);
+        END;
+
+    ELSIF range_expression ~ '^\^\d+\.\d+\.\d+$' THEN
+        -- Matches ^1.2.3 (>=1.2.3 <2.0.0)
+        DECLARE
+            lower_bound TEXT := regexp_replace(range_expression, '\^', '');
+            upper_bound_major INT := split_part(lower_bound, '.', 1)::INT + 1;
+            upper_bound TEXT := upper_bound_major || '.0.0';
+        BEGIN
+            satisfies := (version >= lower_bound AND version < upper_bound);
+        END;
+
+    ELSE
+        RAISE EXCEPTION 'Unsupported range expression: %', range_expression;
+    END IF;
+
+    RETURN satisfies;
+END;
+$$ LANGUAGE plpgsql;
+

package/sql/semver_satisfies.test.ts

@@ -0,0 +1,26 @@
+import { PGlite } from "@electric-sql/pglite";
+import { setupSemverSatisfiesTestSuite } from "@hot-updater/core/test-utils";
+import { afterAll, describe } from "vitest";
+import { prepareSql } from "./prepareSql";
+
+const db = new PGlite();
+const sql = await prepareSql();
+await db.exec(sql);
+
+const createSemverSatisfies =
+  (db: PGlite) => async (targetAppVersion: string, currentVersion: string) => {
+    const result = await db.query<{ actual: boolean }>(`
+    SELECT semver_satisfies('${targetAppVersion}', '${currentVersion}') AS actual;
+  `);
+    return result.rows[0].actual;
+  };
+
+const semverSatisfies = createSemverSatisfies(db);
+
+describe("semverSatisfies", () => {
+  afterAll(async () => {
+    await db.close();
+  });
+
+  setupSemverSatisfiesTestSuite({ semverSatisfies });
+});

package/dist/index.d.cts

@@ -1,8 +0,0 @@
-import { DatabasePluginHooks, BasePluginArgs, DatabasePlugin } from '@hot-updater/plugin-core';
-import { PoolConfig } from 'pg';
-
-interface PostgresConfig extends PoolConfig {
-}
-declare const postgres: (config: PostgresConfig, hooks?: DatabasePluginHooks) => (_: BasePluginArgs) => DatabasePlugin;
-
-export { type PostgresConfig, postgres };