@hot-updater/postgres 0.1.6-0 → 0.3.0

package/dist/index.cjs

@@ -1,126 +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_url: bundle.fileUrl,
-            force_update: bundle.forceUpdate,
-            file_hash: bundle.fileHash,
-            git_commit_hash: bundle.gitCommitHash,
-            message: bundle.message,
-            platform: bundle.platform,
-            target_version: bundle.targetVersion
-          }).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_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,
-        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,
-        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,
-        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,
-        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,99 +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_url: bundle.fileUrl,
-            force_update: bundle.forceUpdate,
-            file_hash: bundle.fileHash,
-            git_commit_hash: bundle.gitCommitHash,
-            message: bundle.message,
-            platform: bundle.platform,
-            target_version: bundle.targetVersion
-          }).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_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,
-        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,
-        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,
-        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,
-        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,10 +1,17 @@
 {
   "name": "@hot-updater/postgres",
   "type": "module",
-  "version": "0.1.6-0",
+  "version": "0.3.0",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./sql": "./sql"
+  },
   "types": "dist/index.d.ts",
   "license": "MIT",
   "repository": "https://github.com/gronxb/hot-updater",
@@ -22,9 +29,9 @@
     "package.json"
   ],
   "dependencies": {
-    "@hot-updater/core": "0.1.6-0",
-    "@hot-updater/plugin-core": "0.1.6-0",
-    "kysely": "^0.27.4",
+    "@hot-updater/core": "0.3.0",
+    "@hot-updater/plugin-core": "0.3.0",
+    "kysely": "^0.27.5",
     "pg": "^8.13.1"
   },
   "devDependencies": {
@@ -33,7 +40,7 @@
     "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

@@ -1,9 +1,11 @@
+-- HotUpdater.bundles
+
 CREATE TYPE platforms AS ENUM ('ios', 'android');
 
 CREATE TABLE bundles (
     id uuid PRIMARY KEY,
     platform platforms NOT NULL,
-    target_version text NOT NULL,
+    target_app_version text NOT NULL,
     force_update boolean NOT NULL,
     enabled boolean NOT NULL,
     file_url text NOT NULL,
@@ -11,3 +13,5 @@ CREATE TABLE bundles (
     git_commit_hash text,
     message text
 );
+
+CREATE INDEX bundles_target_app_version_idx ON bundles(target_app_version);

package/sql/get_update_info.sql

@@ -1,7 +1,9 @@
+-- HotUpdater.get_update_info
+
 CREATE OR REPLACE FUNCTION get_update_info (
-    current_platform   platforms,
-    current_app_version text,
-    current_bundle_id  uuid
+    app_platform   platforms,
+    app_version text,
+    bundle_id  uuid
 )
 RETURNS TABLE (
     id            uuid,
@@ -27,8 +29,8 @@ BEGIN
             'ROLLBACK' AS status
         FROM bundles b
         WHERE b.enabled = TRUE
-          AND b.platform = current_platform
-          AND b.id < current_bundle_id
+          AND b.platform = app_platform
+          AND b.id < bundle_id
         ORDER BY b.id DESC
         LIMIT 1
     ),
@@ -41,9 +43,9 @@ BEGIN
             'UPDATE' AS status
         FROM bundles b
         WHERE b.enabled = TRUE
-          AND b.platform = current_platform
-          AND b.id >= current_bundle_id
-          AND semver_satisfies(b.target_version, current_app_version)
+          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
     ),
@@ -58,11 +60,11 @@ BEGIN
         WHERE NOT EXISTS (SELECT 1 FROM update_candidate)
     )
     SELECT *
-    FROM final_result WHERE final_result.id != current_bundle_id
+    FROM final_result WHERE final_result.id != bundle_id
 
     UNION ALL
     /*
-      When there are no final results and current_bundle_id != NIL_UUID,
+      When there are no final results and bundle_id != NIL_UUID,
       add one fallback row.
       This fallback row is also ROLLBACK so forceUpdate = TRUE.
     */
@@ -73,7 +75,7 @@ BEGIN
         NULL          AS file_hash,
         'ROLLBACK'    AS status
     WHERE (SELECT COUNT(*) FROM final_result) = 0
-      AND current_bundle_id != NIL_UUID;
+      AND bundle_id != NIL_UUID;
 
 END;
 $$;

package/sql/get_update_info.test.ts

@@ -8,14 +8,14 @@ import { prepareSql } from "./prepareSql";
 const createInsertBundleQuery = (bundle: Bundle) => {
   return `
     INSERT INTO bundles (
-      id, file_url, file_hash, platform, target_version,
+      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.targetVersion}',
+      '${bundle.targetAppVersion}',
       ${bundle.forceUpdate},
       ${bundle.enabled},
       ${bundle.gitCommitHash ? `'${bundle.gitCommitHash}'` : "null"},

package/sql/{semver.sql → semver_satisfies.sql}

@@ -1,3 +1,5 @@
+-- HotUpdater.semver_satisfies
+
 CREATE OR REPLACE FUNCTION semver_satisfies(range_expression TEXT, version TEXT)
 RETURNS BOOLEAN AS $$
 DECLARE

package/sql/semver_satisfies.test.ts

@@ -8,9 +8,9 @@ const sql = await prepareSql();
 await db.exec(sql);
 
 const createSemverSatisfies =
-  (db: PGlite) => async (targetVersion: string, currentVersion: string) => {
+  (db: PGlite) => async (targetAppVersion: string, currentVersion: string) => {
     const result = await db.query<{ actual: boolean }>(`
-    SELECT semver_satisfies('${targetVersion}', '${currentVersion}') AS actual;
+    SELECT semver_satisfies('${targetAppVersion}', '${currentVersion}') AS actual;
   `);
     return result.rows[0].actual;
   };

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