@things-factory/shell 10.1.123 → 10.1.142

package/dist-server/typeorm/write-lock.d.ts

@@ -0,0 +1,16 @@
+import type { EntityManager } from 'typeorm';
+/**
+ * **Can this database hold a row for us while we decide?** — `SELECT … FOR UPDATE` where it exists.
+ *
+ * True only inside an open transaction on a driver that has row locks. sqlite has none, and TypeORM throws
+ * `LockNotSupportedOnGivenDriverError` if asked; it does not need one, because a single writer makes a second
+ * writing transaction wait for the first as a whole. Every other driver this platform runs on (postgres,
+ * mysql, mssql, oracle) takes the lock.
+ *
+ * Outside a transaction a lock would be released as soon as the statement ends, so it is not asked for.
+ *
+ * ```ts
+ * repository.findOne({ where, ...(writeLockSupported(tx) ? { lock: { mode: 'pessimistic_write' } } : {}) })
+ * ```
+ */
+export declare function writeLockSupported(manager: Pick<EntityManager, 'connection' | 'queryRunner'>): boolean;

package/dist-server/typeorm/write-lock.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLockSupported = writeLockSupported;
+/**
+ * **Can this database hold a row for us while we decide?** — `SELECT … FOR UPDATE` where it exists.
+ *
+ * True only inside an open transaction on a driver that has row locks. sqlite has none, and TypeORM throws
+ * `LockNotSupportedOnGivenDriverError` if asked; it does not need one, because a single writer makes a second
+ * writing transaction wait for the first as a whole. Every other driver this platform runs on (postgres,
+ * mysql, mssql, oracle) takes the lock.
+ *
+ * Outside a transaction a lock would be released as soon as the statement ends, so it is not asked for.
+ *
+ * ```ts
+ * repository.findOne({ where, ...(writeLockSupported(tx) ? { lock: { mode: 'pessimistic_write' } } : {}) })
+ * ```
+ */
+function writeLockSupported(manager) {
+    const type = manager.connection?.options?.type;
+    return Boolean(manager.queryRunner?.isTransactionActive) && !SINGLE_WRITER_DRIVERS.includes(type ?? '');
+}
+const SINGLE_WRITER_DRIVERS = ['sqlite', 'better-sqlite3', 'sqljs'];
+//# sourceMappingURL=write-lock.js.map

package/dist-server/typeorm/write-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-lock.js","sourceRoot":"","sources":["../../server/typeorm/write-lock.ts"],"names":[],"mappings":";;AAgBA,gDAGC;AAjBD;;;;;;;;;;;;;GAaG;AACH,SAAgB,kBAAkB,CAAC,OAA0D;IAC3F,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,OAAO,EAAE,IAA0B,CAAA;IACpE,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,mBAAmB,CAAC,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;AACzG,CAAC;AAED,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,CAAA","sourcesContent":["import type { EntityManager } from 'typeorm'\n\n/**\n * **Can this database hold a row for us while we decide?** — `SELECT … FOR UPDATE` where it exists.\n *\n * True only inside an open transaction on a driver that has row locks. sqlite has none, and TypeORM throws\n * `LockNotSupportedOnGivenDriverError` if asked; it does not need one, because a single writer makes a second\n * writing transaction wait for the first as a whole. Every other driver this platform runs on (postgres,\n * mysql, mssql, oracle) takes the lock.\n *\n * Outside a transaction a lock would be released as soon as the statement ends, so it is not asked for.\n *\n * ```ts\n * repository.findOne({ where, ...(writeLockSupported(tx) ? { lock: { mode: 'pessimistic_write' } } : {}) })\n * ```\n */\nexport function writeLockSupported(manager: Pick<EntityManager, 'connection' | 'queryRunner'>): boolean {\n  const type = manager.connection?.options?.type as string | undefined\n  return Boolean(manager.queryRunner?.isTransactionActive) && !SINGLE_WRITER_DRIVERS.includes(type ?? '')\n}\n\nconst SINGLE_WRITER_DRIVERS = ['sqlite', 'better-sqlite3', 'sqljs']\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "10.1.123",
+  "version": "10.1.142",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -126,5 +126,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "9781f1eb37a7e6a37285878cff16f8683747eb7a"
+  "gitHead": "73522201151b0156168b0eeea15f2962cda0bd8f"
 }

package/tests/write-lock.test.ts

@@ -0,0 +1,27 @@
+import { writeLockSupported } from '../server/typeorm/write-lock'
+
+/**
+ * A row lock is asked for only where the driver has one and a transaction will hold it.
+ *
+ * Asking sqlite throws `LockNotSupportedOnGivenDriverError`; asking outside a transaction locks nothing.
+ */
+const manager = (type: string, isTransactionActive?: boolean) =>
+  ({
+    connection: { options: { type } },
+    queryRunner: isTransactionActive === undefined ? undefined : { isTransactionActive }
+  }) as any
+
+describe('writeLockSupported', () => {
+  it.each(['postgres', 'mysql', 'mariadb', 'mssql', 'oracle'])('locks on %s inside a transaction', type => {
+    expect(writeLockSupported(manager(type, true))).toBe(true)
+  })
+
+  it.each(['sqlite', 'better-sqlite3', 'sqljs'])('does not lock on %s, which has a single writer', type => {
+    expect(writeLockSupported(manager(type, true))).toBe(false)
+  })
+
+  it('does not lock outside a transaction', () => {
+    expect(writeLockSupported(manager('postgres', false))).toBe(false)
+    expect(writeLockSupported(manager('postgres'))).toBe(false)
+  })
+})