@ad-sdk/bgd 0.0.4 → 0.0.6

package/allocators/buffer.d.ts

@@ -101,6 +101,18 @@ export declare class MemoryBuffer<T extends ArrayBuffer | SharedArrayBuffer = Ar
      * invalidate the disposal logic resulting in a memory leak.
      */
     valueOf(secure: false): Buffer | null;
+    /**
+     * **ATTENTION:** If you use this function make sure that
+     * will not create an external reference of the buffer, or it'll
+     * invalidate the disposal logic resulting in a memory leak.
+     */
+    $ref(secure?: true): T;
+    /**
+     * **ATTENTION:** If you use this function make sure that
+     * will not create an external reference of the buffer, or it'll
+     * invalidate the disposal logic resulting in a memory leak.
+     */
+    $ref(secure: false): T | null;
     /**
      * Clear current buffer and free allocated memory.
      *

package/allocators/buffer.js

@@ -360,6 +360,28 @@ class MemoryBuffer {
     return _classPrivateFieldGet(_BufRef, this);
   }
 
+  /**
+   * **ATTENTION:** If you use this function make sure that
+   * will not create an external reference of the buffer, or it'll
+   * invalidate the disposal logic resulting in a memory leak.
+   */
+
+  /**
+   * **ATTENTION:** If you use this function make sure that
+   * will not create an external reference of the buffer, or it'll
+   * invalidate the disposal logic resulting in a memory leak.
+   */
+
+  $ref(secure) {
+    if (_classPrivateFieldGet(_BufRef, this) == null) {
+      if (secure !== false) {
+        _assertClassBrand(_MemoryBuffer_brand, this, _CheckDisposed).call(this);
+      }
+      return null;
+    }
+    return _classPrivateFieldGet(_BufRef, this).buffer;
+  }
+
   /**
    * Clear current buffer and free allocated memory.
    * 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ad-sdk/bgd",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "index.js",
   "license": "BSD-3-Clause",
   "repository": {

package/sqlx/core.d.ts

@@ -8,4 +8,29 @@
  * @signphrase It was created on Earth by humans, although
  *             I can't define what a "human" is.
  */
+import { ConnectionOptions } from "node:tls";
+import { BGDException } from "../errors";
+import { type Either } from "../lifecycle";
 export declare const SQL_MIGRATION_FILE_PATTERN: RegExp;
+export type ConnectionProps = string | {
+    get(): Promise<Either<unknown, string>> | string;
+} | {
+    host: string;
+    port?: number;
+    username: string;
+    password: string | {
+        get(): Promise<Either<unknown, string>> | Either<unknown, string>;
+    };
+    database: string;
+};
+export interface DatabaseOptions {
+    ssl?: boolean | ConnectionOptions;
+    connectionTimeout?: number;
+    onError?: (err: BGDException) => unknown;
+    verbose?: boolean;
+    replication?: {
+        master: ConnectionProps;
+        slaves: readonly ConnectionProps[];
+        replicationMode?: "slave" | "master";
+    } | false;
+}

package/sqlx/migrations.js

@@ -61,7 +61,7 @@ async function migrate(driver, directory, options) {
       const res = await tx.execBatch([{
         query: fc.trim()
       }, {
-        query: `INSERT INTO ad_bgd_migrations (
+        query: `INSERT INTO bgd_migrations (
             migration_id, filename, sort_index
           ) VALUES ($1::TEXT, $2::TEXT, $3::INT)`,
         values: [(0, _uidlib.uuidv7)(), contentsList[0].name, parseInt(contentsList[i].name.split("_")[0], 10)]

package/sqlx/postgres.d.ts

@@ -13,13 +13,14 @@ import type { Dict } from "../types";
 import { BGDException } from "../errors";
 import { IAsyncDisposable } from "../lifecycle/disposable";
 import { type Either } from "../lifecycle/either";
+import type { ConnectionProps, DatabaseOptions } from "./core";
 import { Database, IAbstractQueryResult, ITransaction } from "./database";
 export interface IPostgresResult<T = Dict<any>> extends IAbstractQueryResult<T> {
     readonly dialect: "pgsql";
 }
 export declare class Postgres extends Database implements IAsyncDisposable {
     #private;
-    constructor();
+    constructor(conn: ConnectionProps, opts?: DatabaseOptions);
     get dialect(): "pgsql";
     exec<T = Dict<unknown>>(query: string, values?: unknown[], options?: {
         transaction?: PoolClient;

package/sqlx/postgres.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PostgresTransaction = exports.Postgres = void 0;
+var _pg = require("pg");
 var _errors = require("../errors");
 var _either = require("../lifecycle/either");
 var _database = require("./database");
@@ -25,14 +26,22 @@ function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.h
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 var _PoolI = /*#__PURE__*/new WeakMap();
 var _Disposed = /*#__PURE__*/new WeakMap();
+var _Options = /*#__PURE__*/new WeakMap();
+var _Conn = /*#__PURE__*/new WeakMap();
 var _Postgres_brand = /*#__PURE__*/new WeakSet();
 class Postgres extends _database.Database {
-  constructor() {
+  constructor(conn, opts) {
     super();
     _classPrivateMethodInitSpec(this, _Postgres_brand);
     _classPrivateFieldInitSpec(this, _PoolI, void 0);
     _classPrivateFieldInitSpec(this, _Disposed, void 0);
+    _classPrivateFieldInitSpec(this, _Options, void 0);
+    _classPrivateFieldInitSpec(this, _Conn, void 0);
     _classPrivateFieldSet(_Disposed, this, false);
+    _classPrivateFieldSet(_Options, this, opts ?? {});
+    delete _classPrivateFieldGet(_Options, this).replication; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+    _classPrivateFieldSet(_Conn, this, conn);
   }
   get dialect() {
     return "pgsql";
@@ -83,14 +92,48 @@ class Postgres extends _database.Database {
   }
   async dispose() {
     if (!_classPrivateFieldGet(_Disposed, this)) {
-      await _classPrivateFieldGet(_PoolI, this)?.end();
+      try {
+        await _classPrivateFieldGet(_PoolI, this)?.end();
+      } catch (err) {
+        console.error(err);
+      }
       _classPrivateFieldSet(_Disposed, this, true);
     }
   }
 }
 exports.Postgres = Postgres;
-function _GetConnection() {
-  throw _assertClassBrand(_Postgres_brand, this, _CheckDisposed);
+async function _GetConnection() {
+  if (_classPrivateFieldGet(_PoolI, this) == null) {
+    if (!_classPrivateFieldGet(_Conn, this)) {
+      throw new _errors.BGDException("[Postgres] Missing connection info for database");
+    }
+    if (typeof _classPrivateFieldGet(_Conn, this) === "object" && "get" in _classPrivateFieldGet(_Options, this)) {
+      throw new _errors.BGDException("[Postgres] Use of secure getters aren't supported yet");
+    }
+    const config = {
+      ssl: _classPrivateFieldGet(_Options, this)?.ssl,
+      allowExitOnIdle: true,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: _classPrivateFieldGet(_Options, this)?.connectionTimeout ?? 2000
+    };
+    if (typeof _classPrivateFieldGet(_Conn, this) === "string") {
+      config.connectionString = _classPrivateFieldGet(_Conn, this);
+    } else if (typeof _classPrivateFieldGet(_Conn, this) === "object" && "host" in _classPrivateFieldGet(_Conn, this)) {
+      if (typeof _classPrivateFieldGet(_Conn, this).password === "object") {
+        throw new _errors.BGDException("[Postgres] Use of secure getters aren't supported yet");
+      }
+      config.host = _classPrivateFieldGet(_Conn, this).host;
+      config.port = _classPrivateFieldGet(_Conn, this).port;
+      config.password = _classPrivateFieldGet(_Conn, this).password;
+      config.database = _classPrivateFieldGet(_Conn, this).database;
+      config.user = _classPrivateFieldGet(_Conn, this).username;
+    } else {
+      throw new _errors.BGDException("[Postgres] Something is wrong with connection info");
+    }
+    _classPrivateFieldSet(_Conn, this, null);
+    _classPrivateFieldSet(_PoolI, this, new _pg.Pool(config));
+  }
+  return await _classPrivateFieldGet(_PoolI, this).connect();
 }
 function _CheckDisposed() {
   if (_classPrivateFieldGet(_Disposed, this)) {
@@ -99,7 +142,7 @@ function _CheckDisposed() {
 }
 var _Finished = /*#__PURE__*/new WeakMap();
 var _Client = /*#__PURE__*/new WeakMap();
-var _Options = /*#__PURE__*/new WeakMap();
+var _Options2 = /*#__PURE__*/new WeakMap();
 class PostgresTransaction {
   static async create(c, o) {
     await c.exec("BEGIN");
@@ -108,10 +151,10 @@ class PostgresTransaction {
   constructor(client, options) {
     _classPrivateFieldInitSpec(this, _Finished, void 0);
     _classPrivateFieldInitSpec(this, _Client, void 0);
-    _classPrivateFieldInitSpec(this, _Options, void 0);
+    _classPrivateFieldInitSpec(this, _Options2, void 0);
     _classPrivateFieldSet(_Finished, this, false);
     _classPrivateFieldSet(_Client, this, client);
-    _classPrivateFieldSet(_Options, this, options ?? {});
+    _classPrivateFieldSet(_Options2, this, options ?? {});
   }
   async commit() {
     if (_classPrivateFieldGet(_Finished, this)) return;
@@ -131,12 +174,12 @@ class PostgresTransaction {
     }
     const result = await _classPrivateFieldGet(_Client, this).exec(text, values);
     if (result.isRight()) {
-      if (_classPrivateFieldGet(_Options, this)?.autoCommit) {
+      if (_classPrivateFieldGet(_Options2, this)?.autoCommit) {
         await this.commit();
       }
       return result;
     }
-    if (_classPrivateFieldGet(_Options, this)?.autoCommit) {
+    if (_classPrivateFieldGet(_Options2, this)?.autoCommit) {
       await this.rollback();
     }
     return result;
@@ -145,7 +188,7 @@ class PostgresTransaction {
     if (_classPrivateFieldGet(_Finished, this)) {
       throw new _errors.BGDException("[PostgresTransaction] Current transaction is already closed");
     }
-    if (!_classPrivateFieldGet(_Options, this)?.allowQueryBatch) {
+    if (!_classPrivateFieldGet(_Options2, this)?.allowQueryBatch) {
       throw new _errors.BGDException("[PostgresTransaction] Current transaction is not allowed to execute batch queries");
     }
     const oe = options?.onError ?? "break";
@@ -159,12 +202,12 @@ class PostgresTransaction {
         }
         result.push(res);
       }
-      if (_classPrivateFieldGet(_Options, this)?.autoCommit !== true) return result;
+      if (_classPrivateFieldGet(_Options2, this)?.autoCommit !== true) return result;
       const success = result.every(r => r.isRight());
       await this[success ? "commit" : "rollback"]();
       return result;
     } catch (err) {
-      if (_classPrivateFieldGet(_Options, this).autoCommit) {
+      if (_classPrivateFieldGet(_Options2, this).autoCommit) {
         await this.rollback();
       }
       throw err;