@things-factory/shell 10.1.122 → 10.1.141

package/dist-server/typeorm/money-column.d.ts

@@ -0,0 +1,34 @@
+import { ColumnOptions, ValueTransformer } from 'typeorm';
+/**
+ * `decimal` 컬럼을 숫자로 읽고 쓰는 변환기.
+ *
+ * Postgres·MySQL 은 `decimal` 을 **문자열**로 돌려준다(정밀도를 지키려고). 그대로 두면
+ * GraphQL `Float` 필드와 합산 코드가 `'1200.00' + 300` 같은 글자 이어붙이기를 한다.
+ * 그래서 읽을 때 숫자로 바꾼다. 비어 있음(`null`·`undefined`)은 그대로 둔다 — 0 으로 만들지 않는다.
+ */
+export declare const decimalTransformer: ValueTransformer;
+/**
+ * 금액 컬럼 — `decimal(18, 2)`.
+ *
+ * ## 왜 `decimal` 인가
+ *
+ * - 형식을 적지 않은 `number` 컬럼은 32비트 정수가 된다. 원 단위로는 정확하지만 한 칸에
+ *   약 21억까지이고 소수(센트)를 못 담는다.
+ * - `float` 은 0.1 을 정확히 담지 못한다. 수천 줄을 더하면 은행 잔액과 어긋난다.
+ * - `decimal` 은 SQL 표준이라 다섯 드라이버(postgres·mysql/mariadb·sqlite·mssql·oracle)가 모두 받는다.
+ *   18자리 중 소수 2자리 — 원화 금액 전부와 외화 센트를 담는다.
+ *
+ * sqlite 는 자릿수를 강제하지 않는다(NUMERIC 친화형). 정수 원화는 정확하지만 소수 금액은
+ * 내부에서 실수로 담길 수 있다 — 소수 금액의 정확성은 서버 DB 를 전제로 한다.
+ *
+ * ## 쓰는 법
+ *
+ * ```ts
+ * @Column({ nullable: true, ...moneyColumn() })
+ * @Field(type => Float, { nullable: true })
+ * supplyAmount?: number
+ * ```
+ *
+ * `nullable`·`default` 같은 나머지 옵션은 호출하는 쪽이 정한다. GraphQL 필드는 `Float` 로 둔다.
+ */
+export declare function moneyColumn(options?: ColumnOptions): ColumnOptions;

package/dist-server/typeorm/money-column.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimalTransformer = void 0;
+exports.moneyColumn = moneyColumn;
+/**
+ * `decimal` 컬럼을 숫자로 읽고 쓰는 변환기.
+ *
+ * Postgres·MySQL 은 `decimal` 을 **문자열**로 돌려준다(정밀도를 지키려고). 그대로 두면
+ * GraphQL `Float` 필드와 합산 코드가 `'1200.00' + 300` 같은 글자 이어붙이기를 한다.
+ * 그래서 읽을 때 숫자로 바꾼다. 비어 있음(`null`·`undefined`)은 그대로 둔다 — 0 으로 만들지 않는다.
+ */
+exports.decimalTransformer = {
+    to: (value) => (value === undefined ? undefined : value === null || value === '' ? null : Number(value)),
+    from: (value) => (value === null || value === undefined ? value : Number(value))
+};
+/**
+ * 금액 컬럼 — `decimal(18, 2)`.
+ *
+ * ## 왜 `decimal` 인가
+ *
+ * - 형식을 적지 않은 `number` 컬럼은 32비트 정수가 된다. 원 단위로는 정확하지만 한 칸에
+ *   약 21억까지이고 소수(센트)를 못 담는다.
+ * - `float` 은 0.1 을 정확히 담지 못한다. 수천 줄을 더하면 은행 잔액과 어긋난다.
+ * - `decimal` 은 SQL 표준이라 다섯 드라이버(postgres·mysql/mariadb·sqlite·mssql·oracle)가 모두 받는다.
+ *   18자리 중 소수 2자리 — 원화 금액 전부와 외화 센트를 담는다.
+ *
+ * sqlite 는 자릿수를 강제하지 않는다(NUMERIC 친화형). 정수 원화는 정확하지만 소수 금액은
+ * 내부에서 실수로 담길 수 있다 — 소수 금액의 정확성은 서버 DB 를 전제로 한다.
+ *
+ * ## 쓰는 법
+ *
+ * ```ts
+ * @Column({ nullable: true, ...moneyColumn() })
+ * @Field(type => Float, { nullable: true })
+ * supplyAmount?: number
+ * ```
+ *
+ * `nullable`·`default` 같은 나머지 옵션은 호출하는 쪽이 정한다. GraphQL 필드는 `Float` 로 둔다.
+ */
+function moneyColumn(options = {}) {
+    return { type: 'decimal', precision: 18, scale: 2, transformer: exports.decimalTransformer, ...options };
+}
+//# sourceMappingURL=money-column.js.map

package/dist-server/typeorm/money-column.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"money-column.js","sourceRoot":"","sources":["../../server/typeorm/money-column.ts"],"names":[],"mappings":";;;AAsCA,kCAEC;AAtCD;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAqB;IAClD,EAAE,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjH,IAAI,EAAE,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;CAC1F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,WAAW,CAAC,UAAyB,EAAE;IACrD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,WAAW,EAAE,0BAAkB,EAAE,GAAG,OAAO,EAAE,CAAA;AAClG,CAAC","sourcesContent":["import { ColumnOptions, ValueTransformer } from 'typeorm'\n\n/**\n * `decimal` 컬럼을 숫자로 읽고 쓰는 변환기.\n *\n * Postgres·MySQL 은 `decimal` 을 **문자열**로 돌려준다(정밀도를 지키려고). 그대로 두면\n * GraphQL `Float` 필드와 합산 코드가 `'1200.00' + 300` 같은 글자 이어붙이기를 한다.\n * 그래서 읽을 때 숫자로 바꾼다. 비어 있음(`null`·`undefined`)은 그대로 둔다 — 0 으로 만들지 않는다.\n */\nexport const decimalTransformer: ValueTransformer = {\n  to: (value: unknown) => (value === undefined ? undefined : value === null || value === '' ? null : Number(value)),\n  from: (value: unknown) => (value === null || value === undefined ? value : Number(value))\n}\n\n/**\n * 금액 컬럼 — `decimal(18, 2)`.\n *\n * ## 왜 `decimal` 인가\n *\n * - 형식을 적지 않은 `number` 컬럼은 32비트 정수가 된다. 원 단위로는 정확하지만 한 칸에\n *   약 21억까지이고 소수(센트)를 못 담는다.\n * - `float` 은 0.1 을 정확히 담지 못한다. 수천 줄을 더하면 은행 잔액과 어긋난다.\n * - `decimal` 은 SQL 표준이라 다섯 드라이버(postgres·mysql/mariadb·sqlite·mssql·oracle)가 모두 받는다.\n *   18자리 중 소수 2자리 — 원화 금액 전부와 외화 센트를 담는다.\n *\n * sqlite 는 자릿수를 강제하지 않는다(NUMERIC 친화형). 정수 원화는 정확하지만 소수 금액은\n * 내부에서 실수로 담길 수 있다 — 소수 금액의 정확성은 서버 DB 를 전제로 한다.\n *\n * ## 쓰는 법\n *\n * ```ts\n * @Column({ nullable: true, ...moneyColumn() })\n * @Field(type => Float, { nullable: true })\n * supplyAmount?: number\n * ```\n *\n * `nullable`·`default` 같은 나머지 옵션은 호출하는 쪽이 정한다. GraphQL 필드는 `Float` 로 둔다.\n */\nexport function moneyColumn(options: ColumnOptions = {}): ColumnOptions {\n  return { type: 'decimal', precision: 18, scale: 2, transformer: decimalTransformer, ...options }\n}\n"]}

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.122",
+  "version": "10.1.141",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -56,7 +56,7 @@
     "@things-factory/ejs-remote": "^10.1.20",
     "@things-factory/env": "^10.1.20",
     "@things-factory/operato-license-checker": "^4.0.4",
-    "@things-factory/styles": "^10.1.122",
+    "@things-factory/styles": "^10.1.123",
     "@things-factory/utils": "^10.1.20",
     "@types/koa": "^3.0.1",
     "@types/koa-bodyparser": "^4.3.13",
@@ -126,5 +126,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "a66715e94ef6064cade05229de57d0fe5798d1fb"
+  "gitHead": "931866a13b9149be42a294f207e245aba11e57f8"
 }

package/tests/money-column.test.ts

@@ -0,0 +1,34 @@
+import { decimalTransformer, moneyColumn } from '../server/typeorm/money-column'
+
+/**
+ * Money is a `decimal(18, 2)` column read back as a number.
+ *
+ * Postgres and MySQL hand `decimal` back as a string. Left alone, a sum over rows becomes string
+ * concatenation ('1200.00' + 300 = '1200.00300') and the GraphQL Float field receives text.
+ */
+describe('a money column', () => {
+  it('is decimal(18, 2) with the number transformer', () => {
+    expect(moneyColumn()).toEqual({ type: 'decimal', precision: 18, scale: 2, transformer: decimalTransformer })
+  })
+
+  it('keeps the options the caller gives', () => {
+    expect(moneyColumn({ nullable: true, default: 0 })).toMatchObject({ type: 'decimal', nullable: true, default: 0 })
+  })
+
+  it('reads a driver string as a number', () => {
+    expect(decimalTransformer.from('1200.00')).toBe(1200)
+    expect(decimalTransformer.from('-71200000.50')).toBe(-71200000.5)
+  })
+
+  it('leaves an empty value empty, never 0', () => {
+    expect(decimalTransformer.from(null)).toBeNull()
+    expect(decimalTransformer.from(undefined)).toBeUndefined()
+    expect(decimalTransformer.to(null)).toBeNull()
+    expect(decimalTransformer.to('')).toBeNull()
+    expect(decimalTransformer.to(undefined)).toBeUndefined()
+  })
+
+  it('writes a number given as text as a number', () => {
+    expect(decimalTransformer.to('658630')).toBe(658630)
+  })
+})

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)
+  })
+})