@things-factory/ops-master 10.1.247 → 10.1.248

package/dist-server/service/resource/class-lineage.d.ts

@@ -1,46 +0,0 @@
-import type { ResourceClassFields } from './resource-class';
-/**
- * 등급 상속을 걷는다 — **`baseIds` 는 네 등급 표에 다 선언되어 있는데 아무도 걷지 않았다.**
- *
- * 표준 `MaterialClassBaseID` · `PersonnelClassBaseID` 는 등급이 등급을 상속한다고 말한다. 우리 표에도
- * 칸이 있고 화면에서 편집도 되고 트윈에도 나간다. 그런데 그 값을 **읽어서 무엇을 답하는 곳이 한 군데도
- * 없었다.** 그래서 「이 품목이 완제품인가」를 물으면 등급 이름 `MC-ECU-FG` 가 나왔다 — 사람은 읽지만
- * 화면은 못 읽는다.
- *
- * ISA-95 에는 「완제품/반제품/원재료」를 담는 전용 요소가 없다. `MaterialDefinitionType` 을 전수로 보면
- * `ID` · `Version` · `Description*` · `PublishedDate` · `EffectiveStartDate`/`EndDate` · `HierarchyScope` ·
- * `SpatialDefinition` · `MaterialDefinitionProperty*` · `MaterialClassID*` · `MaterialLotSourceID*` ·
- * `TestSpecificationID*` · `AssemblyDefinition*` 뿐이다. 표준이 그 구분을 두는 자리는 **등급**이고,
- * 등급 표의 주석도 「원자재·완제품처럼 품목을 묶는 상위 개념」이라고 적고 있다.
- *
- * 그러니 새 축을 만들지 않는다. 이미 있는 상속을 걷는다.
- */
-/** 등급 이름 → 등급. 이름이 등급의 식별자다(표준 `MaterialClassID`). */
-export type ClassIndex = ReadonlyMap<string, ResourceClassFields>;
-/**
- * 한 등급에서 위로 걸어 **뿌리 등급**들을 낸다.
- *
- * 뿌리는 `baseIds` 가 없는 등급이다. 「완제품」·「반제품」·「원재료」처럼 더 위가 없는 것.
- *
- * 답이 여럿일 수 있다 — 한 등급이 두 갈래를 상속하면 뿌리가 둘이다. **하나로 줄이지 않는다.**
- * 줄이면 화면이 「완제품」이라고 단정하는데 실제로는 「완제품이면서 반제품」인 모순을 감춘다. 여럿이면
- * 여럿으로 내고, 그것을 본 사람이 등급을 고치게 한다.
- */
-export declare function rootClassesOf(className: string, index: ClassIndex): string[];
-/**
- * 한 등급에서 뿌리까지의 **경로**를 낸다 — 뿌리가 앞, 자기가 뒤.
- *
- * `['원재료', 'ECU 기구부품']` 처럼 읽는다. 화면이 이것을 그대로 보이면 「이 품목이 무엇인가」를
- * 사람이 한 번에 읽는다.
- *
- * 갈래가 여럿이면 **첫 갈래만** 낸다. 경로는 보여 주기 위한 것이고, 판정은 `rootClassesOf` 로 한다.
- * 여기서 여러 경로를 다 내면 화면 한 칸에 못 담는다.
- */
-export declare function classPathOf(className: string, index: ClassIndex): string[];
-/**
- * 품목 하나가 어느 뿌리 등급들에 드는가 — 등급이 여럿이니 뿌리도 여럿일 수 있다.
- *
- * **등급이 하나도 없으면 빈 배열이다.** 「원재료」로 넘겨짚지 않는다 — 등급을 안 붙인 품목과 원재료를
- * 섞으면, 붙이는 것을 잊었다는 사실이 화면에서 사라진다.
- */
-export declare function rootClassesOfMaterial(classNames: string[] | undefined, index: ClassIndex): string[];

package/dist-server/service/resource/class-lineage.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rootClassesOf = rootClassesOf;
-exports.classPathOf = classPathOf;
-exports.rootClassesOfMaterial = rootClassesOfMaterial;
-/**
- * 한 등급에서 위로 걸어 **뿌리 등급**들을 낸다.
- *
- * 뿌리는 `baseIds` 가 없는 등급이다. 「완제품」·「반제품」·「원재료」처럼 더 위가 없는 것.
- *
- * 답이 여럿일 수 있다 — 한 등급이 두 갈래를 상속하면 뿌리가 둘이다. **하나로 줄이지 않는다.**
- * 줄이면 화면이 「완제품」이라고 단정하는데 실제로는 「완제품이면서 반제품」인 모순을 감춘다. 여럿이면
- * 여럿으로 내고, 그것을 본 사람이 등급을 고치게 한다.
- */
-function rootClassesOf(className, index) {
-    const roots = [];
-    const seen = new Set();
-    const walk = (name) => {
-        /*
-         * **고리를 밟으면 멈춘다.** 화면에서 `baseIds` 를 손으로 넣을 수 있으니 A→B→A 가 만들어질 수
-         * 있다. 그때 이 함수가 안 돌아오면 목록 한 줄이 서버를 세운다.
-         */
-        if (seen.has(name)) {
-            return;
-        }
-        seen.add(name);
-        const klass = index.get(name);
-        /*
-         * **모르는 등급은 그 자체를 뿌리로 낸다.** 등급 표에 없는 이름이 `baseIds` 에 적혀 있을 수 있다
-         * (지워졌거나 오타). 조용히 버리면 계보가 짧아진 채 그럴듯해 보인다 — 이름을 그대로 내서 이상한
-         * 것이 화면에 보이게 한다.
-         */
-        if (!klass) {
-            roots.push(name);
-            return;
-        }
-        const bases = (klass.baseIds ?? []).filter(one => one);
-        if (bases.length === 0) {
-            roots.push(name);
-            return;
-        }
-        for (const base of bases) {
-            walk(base);
-        }
-    };
-    walk(className);
-    return [...new Set(roots)];
-}
-/**
- * 한 등급에서 뿌리까지의 **경로**를 낸다 — 뿌리가 앞, 자기가 뒤.
- *
- * `['원재료', 'ECU 기구부품']` 처럼 읽는다. 화면이 이것을 그대로 보이면 「이 품목이 무엇인가」를
- * 사람이 한 번에 읽는다.
- *
- * 갈래가 여럿이면 **첫 갈래만** 낸다. 경로는 보여 주기 위한 것이고, 판정은 `rootClassesOf` 로 한다.
- * 여기서 여러 경로를 다 내면 화면 한 칸에 못 담는다.
- */
-function classPathOf(className, index) {
-    const path = [];
-    const seen = new Set();
-    let current = className;
-    while (current && !seen.has(current)) {
-        seen.add(current);
-        path.unshift(current);
-        const bases = (index.get(current)?.baseIds ?? []).filter(one => one);
-        current = bases[0];
-    }
-    return path;
-}
-/**
- * 품목 하나가 어느 뿌리 등급들에 드는가 — 등급이 여럿이니 뿌리도 여럿일 수 있다.
- *
- * **등급이 하나도 없으면 빈 배열이다.** 「원재료」로 넘겨짚지 않는다 — 등급을 안 붙인 품목과 원재료를
- * 섞으면, 붙이는 것을 잊었다는 사실이 화면에서 사라진다.
- */
-function rootClassesOfMaterial(classNames, index) {
-    const roots = (classNames ?? []).flatMap(one => rootClassesOf(one, index));
-    return [...new Set(roots)];
-}
-//# sourceMappingURL=class-lineage.js.map

package/dist-server/service/resource/class-lineage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-lineage.js","sourceRoot":"","sources":["../../../server/service/resource/class-lineage.ts"],"names":[],"mappings":";;AA+BA,sCAyCC;AAWD,kCAeC;AAQD,sDAIC;AAxFD;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,SAAiB,EAAE,KAAiB;IAChE,MAAM,KAAK,GAAa,EAAE,CAAA;IAC1B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;IAE9B,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,EAAE;QAC5B;;;WAGG;QACH,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACnB,OAAM;QACR,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEd,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAE7B;;;;WAIG;QACH,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAChB,OAAM;QACR,CAAC;QAED,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;QAEtD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAChB,OAAM;QACR,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,CAAA;QACZ,CAAC;IACH,CAAC,CAAA;IAED,IAAI,CAAC,SAAS,CAAC,CAAA;IAEf,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AAC5B,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,WAAW,CAAC,SAAiB,EAAE,KAAiB;IAC9D,MAAM,IAAI,GAAa,EAAE,CAAA;IACzB,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;IAE9B,IAAI,OAAO,GAAuB,SAAS,CAAA;IAE3C,OAAO,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACrC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QACjB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAErB,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;QACpE,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;IACpB,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,UAAgC,EAAE,KAAiB;IACvF,MAAM,KAAK,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;IAE1E,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;AAC5B,CAAC","sourcesContent":["import type { ResourceClassFields } from './resource-class'\n\n/**\n * 등급 상속을 걷는다 — **`baseIds` 는 네 등급 표에 다 선언되어 있는데 아무도 걷지 않았다.**\n *\n * 표준 `MaterialClassBaseID` · `PersonnelClassBaseID` 는 등급이 등급을 상속한다고 말한다. 우리 표에도\n * 칸이 있고 화면에서 편집도 되고 트윈에도 나간다. 그런데 그 값을 **읽어서 무엇을 답하는 곳이 한 군데도\n * 없었다.** 그래서 「이 품목이 완제품인가」를 물으면 등급 이름 `MC-ECU-FG` 가 나왔다 — 사람은 읽지만\n * 화면은 못 읽는다.\n *\n * ISA-95 에는 「완제품/반제품/원재료」를 담는 전용 요소가 없다. `MaterialDefinitionType` 을 전수로 보면\n * `ID` · `Version` · `Description*` · `PublishedDate` · `EffectiveStartDate`/`EndDate` · `HierarchyScope` ·\n * `SpatialDefinition` · `MaterialDefinitionProperty*` · `MaterialClassID*` · `MaterialLotSourceID*` ·\n * `TestSpecificationID*` · `AssemblyDefinition*` 뿐이다. 표준이 그 구분을 두는 자리는 **등급**이고,\n * 등급 표의 주석도 「원자재·완제품처럼 품목을 묶는 상위 개념」이라고 적고 있다.\n *\n * 그러니 새 축을 만들지 않는다. 이미 있는 상속을 걷는다.\n */\n\n/** 등급 이름 → 등급. 이름이 등급의 식별자다(표준 `MaterialClassID`). */\nexport type ClassIndex = ReadonlyMap<string, ResourceClassFields>\n\n/**\n * 한 등급에서 위로 걸어 **뿌리 등급**들을 낸다.\n *\n * 뿌리는 `baseIds` 가 없는 등급이다. 「완제품」·「반제품」·「원재료」처럼 더 위가 없는 것.\n *\n * 답이 여럿일 수 있다 — 한 등급이 두 갈래를 상속하면 뿌리가 둘이다. **하나로 줄이지 않는다.**\n * 줄이면 화면이 「완제품」이라고 단정하는데 실제로는 「완제품이면서 반제품」인 모순을 감춘다. 여럿이면\n * 여럿으로 내고, 그것을 본 사람이 등급을 고치게 한다.\n */\nexport function rootClassesOf(className: string, index: ClassIndex): string[] {\n  const roots: string[] = []\n  const seen = new Set<string>()\n\n  const walk = (name: string) => {\n    /*\n     * **고리를 밟으면 멈춘다.** 화면에서 `baseIds` 를 손으로 넣을 수 있으니 A→B→A 가 만들어질 수\n     * 있다. 그때 이 함수가 안 돌아오면 목록 한 줄이 서버를 세운다.\n     */\n    if (seen.has(name)) {\n      return\n    }\n    seen.add(name)\n\n    const klass = index.get(name)\n\n    /*\n     * **모르는 등급은 그 자체를 뿌리로 낸다.** 등급 표에 없는 이름이 `baseIds` 에 적혀 있을 수 있다\n     * (지워졌거나 오타). 조용히 버리면 계보가 짧아진 채 그럴듯해 보인다 — 이름을 그대로 내서 이상한\n     * 것이 화면에 보이게 한다.\n     */\n    if (!klass) {\n      roots.push(name)\n      return\n    }\n\n    const bases = (klass.baseIds ?? []).filter(one => one)\n\n    if (bases.length === 0) {\n      roots.push(name)\n      return\n    }\n\n    for (const base of bases) {\n      walk(base)\n    }\n  }\n\n  walk(className)\n\n  return [...new Set(roots)]\n}\n\n/**\n * 한 등급에서 뿌리까지의 **경로**를 낸다 — 뿌리가 앞, 자기가 뒤.\n *\n * `['원재료', 'ECU 기구부품']` 처럼 읽는다. 화면이 이것을 그대로 보이면 「이 품목이 무엇인가」를\n * 사람이 한 번에 읽는다.\n *\n * 갈래가 여럿이면 **첫 갈래만** 낸다. 경로는 보여 주기 위한 것이고, 판정은 `rootClassesOf` 로 한다.\n * 여기서 여러 경로를 다 내면 화면 한 칸에 못 담는다.\n */\nexport function classPathOf(className: string, index: ClassIndex): string[] {\n  const path: string[] = []\n  const seen = new Set<string>()\n\n  let current: string | undefined = className\n\n  while (current && !seen.has(current)) {\n    seen.add(current)\n    path.unshift(current)\n\n    const bases = (index.get(current)?.baseIds ?? []).filter(one => one)\n    current = bases[0]\n  }\n\n  return path\n}\n\n/**\n * 품목 하나가 어느 뿌리 등급들에 드는가 — 등급이 여럿이니 뿌리도 여럿일 수 있다.\n *\n * **등급이 하나도 없으면 빈 배열이다.** 「원재료」로 넘겨짚지 않는다 — 등급을 안 붙인 품목과 원재료를\n * 섞으면, 붙이는 것을 잊었다는 사실이 화면에서 사라진다.\n */\nexport function rootClassesOfMaterial(classNames: string[] | undefined, index: ClassIndex): string[] {\n  const roots = (classNames ?? []).flatMap(one => rootClassesOf(one, index))\n\n  return [...new Set(roots)]\n}\n"]}

package/dist-server/service/resource/class-members.d.ts

@@ -1,36 +0,0 @@
-import { Domain } from '@things-factory/shell';
-/**
- * **이 등급에 무엇이 드나** — 등급 넷이 나눠 쓰는 한 벌.
- *
- * ── 왜 필요한가 ────────────────────────────────────────────────────────────
- * 등급을 만들어 놓고 거기 아무도 안 들어 있는 일이 실제로 있었다. 그러면 「자격이 맞는 사람만 그
- * 공정에 선다」는 규칙이 한 번도 걸린 적이 없다는 뜻인데, 화면에는 등급 이름만 있어서 그 사실이
- * 안 보였다.
- *
- * 등급을 없앨 때도 마찬가지다. 무엇이 딸려 자격을 잃는지 알 수 없었다.
- *
- * ── 넷이 구조가 같다 ───────────────────────────────────────────────────────
- * 표준이 `PersonnelClass` · `EquipmentClass` · `PhysicalAssetClass` · `MaterialClass` 를 따로
- * 정의하지만 「소속을 배열로 든다」는 모양은 같다. 그래서 세는 함수도 하나다 — 넷으로 나누면
- * 한쪽만 고쳐지는 날이 온다.
- *
- * ── 배열 칸이라 훑는다 ─────────────────────────────────────────────────────
- * `personnelClassIds` 는 `simple-json` 이다. 데이터베이스가 그 안을 못 보므로 `IN` 으로 못 좁힌다.
- *
- * **그래서 상한이 있고, 상한에 걸리면 말한다.** 조용히 자르면 「이 등급에 아무도 없다」와 「너무
- * 많아 다 못 봤다」가 같아 보인다. 앞엣것은 고쳐야 할 선언이고 뒤엣것은 멀쩡한 등급이다.
- */
-/** 한 번에 훑을 소속 행 수. 품목의 제조법 훑기와 같은 값을 쓴다. */
-export declare const MEMBER_SCAN_LIMIT = 2000;
-export interface ClassMembers {
-    /** 등급 이름 → 그 등급에 든 것들의 이름. */
-    members: Map<string, string[]>;
-    /** 상한에 걸려 다 보지 못했나. */
-    capped: boolean;
-}
-/**
- * 소속 표를 훑어 등급별로 뒤집는다.
- *
- * `Entity` 는 소속을 가진 쪽(사람 · 설비 · 자산 · 품목)이고, `field` 는 그 소속을 담은 칸 이름이다.
- */
-export declare function scanClassMembers(Entity: any, field: string, domain: Domain): Promise<ClassMembers>;

package/dist-server/service/resource/class-members.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMBER_SCAN_LIMIT = void 0;
-exports.scanClassMembers = scanClassMembers;
-const shell_1 = require("@things-factory/shell");
-const referrers_1 = require("./referrers");
-const material_definition_1 = require("../material/material-definition");
-const material_effective_list_1 = require("../material/material-effective-list");
-/**
- * **이 등급에 무엇이 드나** — 등급 넷이 나눠 쓰는 한 벌.
- *
- * ── 왜 필요한가 ────────────────────────────────────────────────────────────
- * 등급을 만들어 놓고 거기 아무도 안 들어 있는 일이 실제로 있었다. 그러면 「자격이 맞는 사람만 그
- * 공정에 선다」는 규칙이 한 번도 걸린 적이 없다는 뜻인데, 화면에는 등급 이름만 있어서 그 사실이
- * 안 보였다.
- *
- * 등급을 없앨 때도 마찬가지다. 무엇이 딸려 자격을 잃는지 알 수 없었다.
- *
- * ── 넷이 구조가 같다 ───────────────────────────────────────────────────────
- * 표준이 `PersonnelClass` · `EquipmentClass` · `PhysicalAssetClass` · `MaterialClass` 를 따로
- * 정의하지만 「소속을 배열로 든다」는 모양은 같다. 그래서 세는 함수도 하나다 — 넷으로 나누면
- * 한쪽만 고쳐지는 날이 온다.
- *
- * ── 배열 칸이라 훑는다 ─────────────────────────────────────────────────────
- * `personnelClassIds` 는 `simple-json` 이다. 데이터베이스가 그 안을 못 보므로 `IN` 으로 못 좁힌다.
- *
- * **그래서 상한이 있고, 상한에 걸리면 말한다.** 조용히 자르면 「이 등급에 아무도 없다」와 「너무
- * 많아 다 못 봤다」가 같아 보인다. 앞엣것은 고쳐야 할 선언이고 뒤엣것은 멀쩡한 등급이다.
- */
-/** 한 번에 훑을 소속 행 수. 품목의 제조법 훑기와 같은 값을 쓴다. */
-exports.MEMBER_SCAN_LIMIT = 2000;
-/**
- * 소속 표를 훑어 등급별로 뒤집는다.
- *
- * `Entity` 는 소속을 가진 쪽(사람 · 설비 · 자산 · 품목)이고, `field` 는 그 소속을 담은 칸 이름이다.
- */
-async function scanClassMembers(Entity, field, domain) {
-    const repo = (0, shell_1.getRepository)(Entity);
-    if (Entity === material_definition_1.MaterialDefinition) {
-        const { items, total } = await (0, material_effective_list_1.listEffectiveMaterialDefinitions)(repo.manager, domain, {
-            filters: [{ name: 'revisionNumber', operator: 'is_not_null', value: true }],
-            pagination: { page: 1, limit: exports.MEMBER_SCAN_LIMIT }
-        });
-        return { members: (0, referrers_1.indexMultiReferrers)(items, one => one.materialClassIds ?? [], one => one.name), capped: total > items.length };
-    }
-    const total = await repo.count({ where: { domain: { id: domain.id } } });
-    /*
-     * `id` 를 함께 뽑는다. 빼면 TypeORM 이 「no such column: distinctAlias.…_id」로 터진다 — `take` 를
-     * 쓰면 중복 제거를 위해 기본 키로 한 번 더 감싸는데, 그 키를 안 뽑으면 감쌀 것이 없다.
-     */
-    const rows = await repo.find({
-        where: { domain: { id: domain.id } },
-        select: ['id', 'name', field],
-        take: exports.MEMBER_SCAN_LIMIT
-    });
-    const members = (0, referrers_1.indexMultiReferrers)(rows, one => one[field] ?? [], one => one.name);
-    return { members, capped: total > rows.length };
-}
-//# sourceMappingURL=class-members.js.map

package/dist-server/service/resource/class-members.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-members.js","sourceRoot":"","sources":["../../../server/service/resource/class-members.ts"],"names":[],"mappings":";;;AA2CA,4CA4BC;AAvED,iDAA6D;AAE7D,2CAAiD;AACjD,yEAAoE;AACpE,iFAAsF;AAEtF;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,4CAA4C;AAC/B,QAAA,iBAAiB,GAAG,IAAI,CAAA;AASrC;;;;GAIG;AACI,KAAK,UAAU,gBAAgB,CAAC,MAAW,EAAE,KAAa,EAAE,MAAc;IAC/E,MAAM,IAAI,GAAG,IAAA,qBAAa,EAAC,MAAM,CAAC,CAAA;IAClC,IAAI,MAAM,KAAK,wCAAkB,EAAE,CAAC;QAClC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,IAAA,0DAAgC,EAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE;YACpF,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;YAC3E,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,yBAAiB,EAAE;SAC3C,CAAC,CAAA;QACT,OAAO,EAAE,OAAO,EAAE,IAAA,+BAAmB,EAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAA;IAClI,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,EAAS,EAAE,CAAC,CAAA;IAE/E;;;OAGG;IACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC;QAC3B,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,EAAS;QAC3C,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAQ;QACpC,IAAI,EAAE,yBAAiB;KACxB,CAAC,CAAA;IAEF,MAAM,OAAO,GAAG,IAAA,+BAAmB,EACjC,IAAa,EACb,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,EACvB,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAChB,CAAA;IAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,GAAI,IAAc,CAAC,MAAM,EAAE,CAAA;AAC5D,CAAC","sourcesContent":["import { Domain, getRepository } from '@things-factory/shell'\n\nimport { indexMultiReferrers } from './referrers'\nimport { MaterialDefinition } from '../material/material-definition'\nimport { listEffectiveMaterialDefinitions } from '../material/material-effective-list'\n\n/**\n * **이 등급에 무엇이 드나** — 등급 넷이 나눠 쓰는 한 벌.\n *\n * ── 왜 필요한가 ────────────────────────────────────────────────────────────\n * 등급을 만들어 놓고 거기 아무도 안 들어 있는 일이 실제로 있었다. 그러면 「자격이 맞는 사람만 그\n * 공정에 선다」는 규칙이 한 번도 걸린 적이 없다는 뜻인데, 화면에는 등급 이름만 있어서 그 사실이\n * 안 보였다.\n *\n * 등급을 없앨 때도 마찬가지다. 무엇이 딸려 자격을 잃는지 알 수 없었다.\n *\n * ── 넷이 구조가 같다 ───────────────────────────────────────────────────────\n * 표준이 `PersonnelClass` · `EquipmentClass` · `PhysicalAssetClass` · `MaterialClass` 를 따로\n * 정의하지만 「소속을 배열로 든다」는 모양은 같다. 그래서 세는 함수도 하나다 — 넷으로 나누면\n * 한쪽만 고쳐지는 날이 온다.\n *\n * ── 배열 칸이라 훑는다 ─────────────────────────────────────────────────────\n * `personnelClassIds` 는 `simple-json` 이다. 데이터베이스가 그 안을 못 보므로 `IN` 으로 못 좁힌다.\n *\n * **그래서 상한이 있고, 상한에 걸리면 말한다.** 조용히 자르면 「이 등급에 아무도 없다」와 「너무\n * 많아 다 못 봤다」가 같아 보인다. 앞엣것은 고쳐야 할 선언이고 뒤엣것은 멀쩡한 등급이다.\n */\n\n/** 한 번에 훑을 소속 행 수. 품목의 제조법 훑기와 같은 값을 쓴다. */\nexport const MEMBER_SCAN_LIMIT = 2000\n\nexport interface ClassMembers {\n  /** 등급 이름 → 그 등급에 든 것들의 이름. */\n  members: Map<string, string[]>\n  /** 상한에 걸려 다 보지 못했나. */\n  capped: boolean\n}\n\n/**\n * 소속 표를 훑어 등급별로 뒤집는다.\n *\n * `Entity` 는 소속을 가진 쪽(사람 · 설비 · 자산 · 품목)이고, `field` 는 그 소속을 담은 칸 이름이다.\n */\nexport async function scanClassMembers(Entity: any, field: string, domain: Domain): Promise<ClassMembers> {\n  const repo = getRepository(Entity)\n  if (Entity === MaterialDefinition) {\n    const { items, total } = await listEffectiveMaterialDefinitions(repo.manager, domain, {\n      filters: [{ name: 'revisionNumber', operator: 'is_not_null', value: true }],\n      pagination: { page: 1, limit: MEMBER_SCAN_LIMIT }\n    } as any)\n    return { members: indexMultiReferrers(items, one => one.materialClassIds ?? [], one => one.name), capped: total > items.length }\n  }\n  const total = await repo.count({ where: { domain: { id: domain.id } } as any })\n\n  /*\n   * `id` 를 함께 뽑는다. 빼면 TypeORM 이 「no such column: distinctAlias.…_id」로 터진다 — `take` 를\n   * 쓰면 중복 제거를 위해 기본 키로 한 번 더 감싸는데, 그 키를 안 뽑으면 감쌀 것이 없다.\n   */\n  const rows = await repo.find({\n    where: { domain: { id: domain.id } } as any,\n    select: ['id', 'name', field] as any,\n    take: MEMBER_SCAN_LIMIT\n  })\n\n  const members = indexMultiReferrers(\n    rows as any[],\n    one => one[field] ?? [],\n    one => one.name\n  )\n\n  return { members, capped: total > (rows as any[]).length }\n}\n"]}

package/dist-server/service/resource/referrers.d.ts

@@ -1,54 +0,0 @@
-/**
- * **나를 가리키는 것들** — 들어오는 관계를 세는 공통 부분.
- *
- * ── 왜 필요한가 ────────────────────────────────────────────────────────────
- * 마스터의 관계는 전부 「남의 표 칸에 든 이름」 한 가지 모양이다. 커널이 이름으로 주소를 잡기
- * 때문이다. 그래서 나가는 쪽은 그 칸을 그대로 보이면 되는데, **들어오는 쪽은 아무도 안 세었다.**
- *
- * 자리 하나를 열어도 「여기서 누가 일하나 · 무슨 설비가 있나」를 알 수 없었다. 사람 화면을 열어
- * 근무 자리로 거르는 수밖에 없었고, 설비는 또 설비 화면에서 같은 일을 해야 했다.
- *
- * ── 줄마다 세지 않는다 ─────────────────────────────────────────────────────
- * 필드 리졸버는 줄마다 불린다. 거기서 그때그때 세면 `limit 20` 에 질의 20회다 — N+1 이다.
- * 그래서 **페이지의 이름들을 한 번에** 묻고 그 답을 요청 안에 담는다. 담는 것은 결과가 아니라
- * **약속**이다 — 줄들이 거의 동시에 묻기 때문에, 결과를 담으면 스무 개가 각자 질의를 띄운다.
- *
- * `childCount` 가 같은 방식을 쓴다(`location-master-resolver.ts`). 여기서는 그 방식을 축 여럿이
- * 나눠 쓸 수 있게 뽑아 두었다.
- */
-/** 한 줄이 무엇을 가리키나 — 가리키는 이름과, 그 줄 자신의 이름. */
-export interface Referrer {
-    /** 이 줄이 가리키는 대상의 이름. 비었으면 아무도 안 가리킨다. */
-    points?: string | null;
-    /** 이 줄의 이름. 사람이 목록에서 알아보는 값이다. */
-    name?: string | null;
-}
-/**
- * 대상 이름 → 그것을 가리키는 줄들의 이름.
- *
- * **빈 값은 버린다.** 가리키는 곳이 없는 줄과 이름 없는 줄은 관계가 아니다. 그것을 빈 문자열
- * 키로 모으면 「아무 데도 안 놓인 것들」이 한 자리에 뭉쳐 그럴듯한 관계처럼 보인다.
- */
-export declare function indexReferrers(rows: Referrer[]): Map<string, string[]>;
-/**
- * 화면에 보일 만큼만 자르고 **몇이 남았는지 함께 낸다.**
- *
- * 조용히 자르면 「여기 셋이 있다」와 「여기 서른이 있는데 셋만 보인다」가 같아 보인다. 자른 수를
- * 말하지 않으면 그 칸을 보고 사람이 판단을 내린다.
- */
-export declare function cappedList(names: string[] | undefined, limit: number): {
-    shown: string[];
-    hidden: number;
-};
-/**
- * **배열 칸을 가리키는 것들.**
- *
- * `steps` 나 `materialClassIds` 처럼 한 줄이 여럿을 가리키는 칸이 있다. 이런 칸은 `IN` 으로 못
- * 좁힌다 — 저장이 `simple-json` 이라 데이터베이스가 그 안을 못 본다. 그래서 표를 훑어 여기서
- * 뒤집는다.
- *
- * **훑는 데는 반드시 상한이 있어야 하고, 상한에 걸렸으면 말해야 한다.** 조용히 자르면 「이 공정을
- * 아무도 안 쓴다」와 「너무 많아 다 못 봤다」가 같아 보인다. 앞엣것은 지워도 되는 공정이고
- * 뒤엣것은 지우면 라인이 선다.
- */
-export declare function indexMultiReferrers<T>(rows: T[], pointsOf: (row: T) => (string | null | undefined)[], nameOf: (row: T) => string | null | undefined): Map<string, string[]>;

package/dist-server/service/resource/referrers.js

@@ -1,99 +0,0 @@
-"use strict";
-/**
- * **나를 가리키는 것들** — 들어오는 관계를 세는 공통 부분.
- *
- * ── 왜 필요한가 ────────────────────────────────────────────────────────────
- * 마스터의 관계는 전부 「남의 표 칸에 든 이름」 한 가지 모양이다. 커널이 이름으로 주소를 잡기
- * 때문이다. 그래서 나가는 쪽은 그 칸을 그대로 보이면 되는데, **들어오는 쪽은 아무도 안 세었다.**
- *
- * 자리 하나를 열어도 「여기서 누가 일하나 · 무슨 설비가 있나」를 알 수 없었다. 사람 화면을 열어
- * 근무 자리로 거르는 수밖에 없었고, 설비는 또 설비 화면에서 같은 일을 해야 했다.
- *
- * ── 줄마다 세지 않는다 ─────────────────────────────────────────────────────
- * 필드 리졸버는 줄마다 불린다. 거기서 그때그때 세면 `limit 20` 에 질의 20회다 — N+1 이다.
- * 그래서 **페이지의 이름들을 한 번에** 묻고 그 답을 요청 안에 담는다. 담는 것은 결과가 아니라
- * **약속**이다 — 줄들이 거의 동시에 묻기 때문에, 결과를 담으면 스무 개가 각자 질의를 띄운다.
- *
- * `childCount` 가 같은 방식을 쓴다(`location-master-resolver.ts`). 여기서는 그 방식을 축 여럿이
- * 나눠 쓸 수 있게 뽑아 두었다.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indexReferrers = indexReferrers;
-exports.cappedList = cappedList;
-exports.indexMultiReferrers = indexMultiReferrers;
-/**
- * 대상 이름 → 그것을 가리키는 줄들의 이름.
- *
- * **빈 값은 버린다.** 가리키는 곳이 없는 줄과 이름 없는 줄은 관계가 아니다. 그것을 빈 문자열
- * 키로 모으면 「아무 데도 안 놓인 것들」이 한 자리에 뭉쳐 그럴듯한 관계처럼 보인다.
- */
-function indexReferrers(rows) {
-    const index = new Map();
-    for (const row of rows) {
-        const target = (row.points ?? '').trim();
-        const who = (row.name ?? '').trim();
-        if (!target || !who) {
-            continue;
-        }
-        const list = index.get(target) ?? [];
-        /*
-         * 같은 줄이 두 번 들어오면 한 번만 센다. 한 줄이 같은 대상을 두 칸에서 가리키는 축이 생길 수
-         * 있고(자리와 예비 자리처럼), 그때 개수가 부풀면 화면이 「둘이 있다」고 말한다.
-         */
-        if (!list.includes(who)) {
-            list.push(who);
-        }
-        index.set(target, list);
-    }
-    /* 목록의 순서를 정한다 — 같은 자료에 같은 화면이 나와야 한다. */
-    for (const list of index.values()) {
-        list.sort();
-    }
-    return index;
-}
-/**
- * 화면에 보일 만큼만 자르고 **몇이 남았는지 함께 낸다.**
- *
- * 조용히 자르면 「여기 셋이 있다」와 「여기 서른이 있는데 셋만 보인다」가 같아 보인다. 자른 수를
- * 말하지 않으면 그 칸을 보고 사람이 판단을 내린다.
- */
-function cappedList(names, limit) {
-    const all = names ?? [];
-    return { shown: all.slice(0, limit), hidden: Math.max(0, all.length - limit) };
-}
-/**
- * **배열 칸을 가리키는 것들.**
- *
- * `steps` 나 `materialClassIds` 처럼 한 줄이 여럿을 가리키는 칸이 있다. 이런 칸은 `IN` 으로 못
- * 좁힌다 — 저장이 `simple-json` 이라 데이터베이스가 그 안을 못 본다. 그래서 표를 훑어 여기서
- * 뒤집는다.
- *
- * **훑는 데는 반드시 상한이 있어야 하고, 상한에 걸렸으면 말해야 한다.** 조용히 자르면 「이 공정을
- * 아무도 안 쓴다」와 「너무 많아 다 못 봤다」가 같아 보인다. 앞엣것은 지워도 되는 공정이고
- * 뒤엣것은 지우면 라인이 선다.
- */
-function indexMultiReferrers(rows, pointsOf, nameOf) {
-    const index = new Map();
-    for (const row of rows) {
-        const who = (nameOf(row) ?? '').trim();
-        if (!who) {
-            continue;
-        }
-        for (const raw of pointsOf(row) ?? []) {
-            const target = (raw ?? '').trim();
-            if (!target) {
-                continue;
-            }
-            const list = index.get(target) ?? [];
-            if (!list.includes(who)) {
-                list.push(who);
-            }
-            index.set(target, list);
-        }
-    }
-    for (const list of index.values()) {
-        list.sort();
-    }
-    return index;
-}
-//# sourceMappingURL=referrers.js.map

package/dist-server/service/resource/referrers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"referrers.js","sourceRoot":"","sources":["../../../server/service/resource/referrers.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;AAgBH,wCA8BC;AAQD,gCAIC;AAaD,kDAoCC;AAjGD;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,IAAgB;IAC7C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAA;IAEzC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QACxC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QAEnC,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;YACpB,SAAQ;QACV,CAAC;QAED,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;QAEpC;;;WAGG;QACH,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAChB,CAAC;QAED,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACzB,CAAC;IAED,yCAAyC;IACzC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC,IAAI,EAAE,CAAA;IACb,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAC,KAA2B,EAAE,KAAa;IACnE,MAAM,GAAG,GAAG,KAAK,IAAI,EAAE,CAAA;IAEvB,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,EAAE,CAAA;AAChF,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,mBAAmB,CACjC,IAAS,EACT,QAAmD,EACnD,MAA6C;IAE7C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAA;IAEzC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QAEtC,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,SAAQ;QACV,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;YAEjC,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,SAAQ;YACV,CAAC;YAED,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;YAEpC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACxB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAChB,CAAC;YAED,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC,IAAI,EAAE,CAAA;IACb,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["/**\n * **나를 가리키는 것들** — 들어오는 관계를 세는 공통 부분.\n *\n * ── 왜 필요한가 ────────────────────────────────────────────────────────────\n * 마스터의 관계는 전부 「남의 표 칸에 든 이름」 한 가지 모양이다. 커널이 이름으로 주소를 잡기\n * 때문이다. 그래서 나가는 쪽은 그 칸을 그대로 보이면 되는데, **들어오는 쪽은 아무도 안 세었다.**\n *\n * 자리 하나를 열어도 「여기서 누가 일하나 · 무슨 설비가 있나」를 알 수 없었다. 사람 화면을 열어\n * 근무 자리로 거르는 수밖에 없었고, 설비는 또 설비 화면에서 같은 일을 해야 했다.\n *\n * ── 줄마다 세지 않는다 ─────────────────────────────────────────────────────\n * 필드 리졸버는 줄마다 불린다. 거기서 그때그때 세면 `limit 20` 에 질의 20회다 — N+1 이다.\n * 그래서 **페이지의 이름들을 한 번에** 묻고 그 답을 요청 안에 담는다. 담는 것은 결과가 아니라\n * **약속**이다 — 줄들이 거의 동시에 묻기 때문에, 결과를 담으면 스무 개가 각자 질의를 띄운다.\n *\n * `childCount` 가 같은 방식을 쓴다(`location-master-resolver.ts`). 여기서는 그 방식을 축 여럿이\n * 나눠 쓸 수 있게 뽑아 두었다.\n */\n\n/** 한 줄이 무엇을 가리키나 — 가리키는 이름과, 그 줄 자신의 이름. */\nexport interface Referrer {\n  /** 이 줄이 가리키는 대상의 이름. 비었으면 아무도 안 가리킨다. */\n  points?: string | null\n  /** 이 줄의 이름. 사람이 목록에서 알아보는 값이다. */\n  name?: string | null\n}\n\n/**\n * 대상 이름 → 그것을 가리키는 줄들의 이름.\n *\n * **빈 값은 버린다.** 가리키는 곳이 없는 줄과 이름 없는 줄은 관계가 아니다. 그것을 빈 문자열\n * 키로 모으면 「아무 데도 안 놓인 것들」이 한 자리에 뭉쳐 그럴듯한 관계처럼 보인다.\n */\nexport function indexReferrers(rows: Referrer[]): Map<string, string[]> {\n  const index = new Map<string, string[]>()\n\n  for (const row of rows) {\n    const target = (row.points ?? '').trim()\n    const who = (row.name ?? '').trim()\n\n    if (!target || !who) {\n      continue\n    }\n\n    const list = index.get(target) ?? []\n\n    /*\n     * 같은 줄이 두 번 들어오면 한 번만 센다. 한 줄이 같은 대상을 두 칸에서 가리키는 축이 생길 수\n     * 있고(자리와 예비 자리처럼), 그때 개수가 부풀면 화면이 「둘이 있다」고 말한다.\n     */\n    if (!list.includes(who)) {\n      list.push(who)\n    }\n\n    index.set(target, list)\n  }\n\n  /* 목록의 순서를 정한다 — 같은 자료에 같은 화면이 나와야 한다. */\n  for (const list of index.values()) {\n    list.sort()\n  }\n\n  return index\n}\n\n/**\n * 화면에 보일 만큼만 자르고 **몇이 남았는지 함께 낸다.**\n *\n * 조용히 자르면 「여기 셋이 있다」와 「여기 서른이 있는데 셋만 보인다」가 같아 보인다. 자른 수를\n * 말하지 않으면 그 칸을 보고 사람이 판단을 내린다.\n */\nexport function cappedList(names: string[] | undefined, limit: number): { shown: string[]; hidden: number } {\n  const all = names ?? []\n\n  return { shown: all.slice(0, limit), hidden: Math.max(0, all.length - limit) }\n}\n\n/**\n * **배열 칸을 가리키는 것들.**\n *\n * `steps` 나 `materialClassIds` 처럼 한 줄이 여럿을 가리키는 칸이 있다. 이런 칸은 `IN` 으로 못\n * 좁힌다 — 저장이 `simple-json` 이라 데이터베이스가 그 안을 못 본다. 그래서 표를 훑어 여기서\n * 뒤집는다.\n *\n * **훑는 데는 반드시 상한이 있어야 하고, 상한에 걸렸으면 말해야 한다.** 조용히 자르면 「이 공정을\n * 아무도 안 쓴다」와 「너무 많아 다 못 봤다」가 같아 보인다. 앞엣것은 지워도 되는 공정이고\n * 뒤엣것은 지우면 라인이 선다.\n */\nexport function indexMultiReferrers<T>(\n  rows: T[],\n  pointsOf: (row: T) => (string | null | undefined)[],\n  nameOf: (row: T) => string | null | undefined\n): Map<string, string[]> {\n  const index = new Map<string, string[]>()\n\n  for (const row of rows) {\n    const who = (nameOf(row) ?? '').trim()\n\n    if (!who) {\n      continue\n    }\n\n    for (const raw of pointsOf(row) ?? []) {\n      const target = (raw ?? '').trim()\n\n      if (!target) {\n        continue\n      }\n\n      const list = index.get(target) ?? []\n\n      if (!list.includes(who)) {\n        list.push(who)\n      }\n\n      index.set(target, list)\n    }\n  }\n\n  for (const list of index.values()) {\n    list.sort()\n  }\n\n  return index\n}\n"]}

package/dist-server/service/resource/resource-class.d.ts

@@ -1,25 +0,0 @@
-import type { ResourceClassDef } from '@operato/ops-contract';
-/**
- * 등급을 트윈이 받는 모양으로 옮긴다 — **자원 셋이 같은 함수를 쓴다.**
- *
- * ISA-95 는 `PersonnelClass` · `EquipmentClass` · `PhysicalAssetClass` 를 따로 정의하지만 구조는 같다.
- * 계약 층도 그것을 `ResourceClassDef` 하나로 갖는다. 그래서 옮기는 함수도 하나다 — 셋으로 나누면 한쪽만
- * 고쳐지는 날이 온다.
- *
- * 표(엔티티)는 셋으로 나눈다. 등급은 자원 하나에만 속하고, 한 표에 담으면 인원 등급을 설비에 붙이는
- * 일을 막을 방법이 없다.
- */
-/** 등급 엔티티가 공통으로 갖는 칸. 세 표가 같은 모양이다. */
-export interface ResourceClassFields {
-    name: string;
-    description?: string;
-    baseIds?: string[];
-    testSpecificationIds?: string[];
-    properties?: Record<string, unknown>[];
-    effectiveStart?: Date;
-    effectiveEnd?: Date;
-}
-/** 빈 값은 칸을 만들지 않는다 — 빈 칸은 「비어 있다」와 「그런 것이 없다」를 섞는다. */
-export declare function put<T>(target: Record<string, unknown>, key: string, value: T | undefined | null): void;
-export declare function iso(at: Date | undefined): string | undefined;
-export declare function toResourceClassDef(klass: ResourceClassFields): ResourceClassDef;

package/dist-server/service/resource/resource-class.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.put = put;
-exports.iso = iso;
-exports.toResourceClassDef = toResourceClassDef;
-/** 빈 값은 칸을 만들지 않는다 — 빈 칸은 「비어 있다」와 「그런 것이 없다」를 섞는다. */
-function put(target, key, value) {
-    if (value === undefined || value === null) {
-        return;
-    }
-    if (Array.isArray(value) && value.length === 0) {
-        return;
-    }
-    target[key] = value;
-}
-function iso(at) {
-    return at ? new Date(at).toISOString() : undefined;
-}
-function toResourceClassDef(klass) {
-    const out = { id: klass.name };
-    put(out, 'description', klass.description);
-    put(out, 'baseIds', klass.baseIds);
-    put(out, 'testSpecificationIds', klass.testSpecificationIds);
-    put(out, 'properties', klass.properties);
-    put(out, 'effectiveStart', iso(klass.effectiveStart));
-    put(out, 'effectiveEnd', iso(klass.effectiveEnd));
-    return out;
-}
-//# sourceMappingURL=resource-class.js.map

package/dist-server/service/resource/resource-class.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resource-class.js","sourceRoot":"","sources":["../../../server/service/resource/resource-class.ts"],"names":[],"mappings":";;AAyBA,kBAQC;AAED,kBAEC;AAED,gDAWC;AA1BD,uDAAuD;AACvD,SAAgB,GAAG,CAAI,MAA+B,EAAE,GAAW,EAAE,KAA2B;IAC9F,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAM;IACR,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/C,OAAM;IACR,CAAC;IACD,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AACrB,CAAC;AAED,SAAgB,GAAG,CAAC,EAAoB;IACtC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA;AACpD,CAAC;AAED,SAAgB,kBAAkB,CAAC,KAA0B;IAC3D,MAAM,GAAG,GAA4B,EAAE,EAAE,EAAE,KAAK,CAAC,IAAI,EAAE,CAAA;IAEvD,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,CAAC,WAAW,CAAC,CAAA;IAC1C,GAAG,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IAClC,GAAG,CAAC,GAAG,EAAE,sBAAsB,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAA;IAC5D,GAAG,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;IACxC,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAA;IACrD,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAA;IAEjD,OAAO,GAAkC,CAAA;AAC3C,CAAC","sourcesContent":["import type { ResourceClassDef } from '@operato/ops-contract'\n\n/**\n * 등급을 트윈이 받는 모양으로 옮긴다 — **자원 셋이 같은 함수를 쓴다.**\n *\n * ISA-95 는 `PersonnelClass` · `EquipmentClass` · `PhysicalAssetClass` 를 따로 정의하지만 구조는 같다.\n * 계약 층도 그것을 `ResourceClassDef` 하나로 갖는다. 그래서 옮기는 함수도 하나다 — 셋으로 나누면 한쪽만\n * 고쳐지는 날이 온다.\n *\n * 표(엔티티)는 셋으로 나눈다. 등급은 자원 하나에만 속하고, 한 표에 담으면 인원 등급을 설비에 붙이는\n * 일을 막을 방법이 없다.\n */\n\n/** 등급 엔티티가 공통으로 갖는 칸. 세 표가 같은 모양이다. */\nexport interface ResourceClassFields {\n  name: string\n  description?: string\n  baseIds?: string[]\n  testSpecificationIds?: string[]\n  properties?: Record<string, unknown>[]\n  effectiveStart?: Date\n  effectiveEnd?: Date\n}\n\n/** 빈 값은 칸을 만들지 않는다 — 빈 칸은 「비어 있다」와 「그런 것이 없다」를 섞는다. */\nexport function put<T>(target: Record<string, unknown>, key: string, value: T | undefined | null): void {\n  if (value === undefined || value === null) {\n    return\n  }\n  if (Array.isArray(value) && value.length === 0) {\n    return\n  }\n  target[key] = value\n}\n\nexport function iso(at: Date | undefined): string | undefined {\n  return at ? new Date(at).toISOString() : undefined\n}\n\nexport function toResourceClassDef(klass: ResourceClassFields): ResourceClassDef {\n  const out: Record<string, unknown> = { id: klass.name }\n\n  put(out, 'description', klass.description)\n  put(out, 'baseIds', klass.baseIds)\n  put(out, 'testSpecificationIds', klass.testSpecificationIds)\n  put(out, 'properties', klass.properties)\n  put(out, 'effectiveStart', iso(klass.effectiveStart))\n  put(out, 'effectiveEnd', iso(klass.effectiveEnd))\n\n  return out as unknown as ResourceClassDef\n}\n"]}

package/dist-server/service/revision-baseline.d.ts

@@ -1,71 +0,0 @@
-import { DataSource, EntityManager } from 'typeorm';
-import { Domain } from '@things-factory/shell';
-/**
- * **버전을 올린 설치본의 기준정보에 첫 개정본을 세운다** — 기준선(2026-09-24, 수석 아키텍트 판정).
- *
- * ── 왜 필요한가 ────────────────────────────────────────────────────────────
- * 개정 체계(10.1.35)는 새로 만드는 기준정보만 개정본으로 받았고, **그 전부터 있던 행을 들이는 길이
- * 없었다.** 그래서 버전을 올린 설치본은 레시피 · 품목 · 검사 명세의 개정본이 0 이고, 새 지시가 레시피를
- * 못 고르고 품목 근거를 못 찍어 **새 생산이 한 건도 안 섰다.**
- *
- * ── 왜 결재 없이, 왜 기동 때인가 ───────────────────────────────────────────
- * 첫 개정본이 단정하는 것은 「지금 이 값으로 돌고 있다」뿐이고, 시스템이 이미 그렇게 돌고 있다. 누를
- * 사람이 판단할 것이 없다. 그리고 **유효 시작이 이를수록 「모른다」 구간이 좁다** — 처음 쓰일 때 세우면
- * 버전 올린 뒤부터 첫 사용까지가 모르는 구간이 된다. 규제 축도 같다 — 통제하는 것은 **바꾸는 일**이고
- * 기준선은 아무것도 안 바꾼다. 대신 자기 성격을 이름으로 댄다(발행 종류 `baseline`, 결재자 없음).
- *
- * ── 지키는 것 ──────────────────────────────────────────────────────────────
- * - 개정본이 0 인 루트만. 찾는 것은 축마다 질의 하나다.
- * - 두 번 돌아도, 서버 둘이 동시에 떠도 하나만 선다 — 개정 번호 유니크와 루트의 세대 조건부 갱신이 막는다.
- * - **도메인 × 축마다 트랜잭션 하나.** 하나가 실패해도 나머지는 선다. 실패한 도메인과 축을 크게 말한다.
- * - 세운 시각은 서버가 정한다 — 도메인마다 한 순간.
- * - 읽는 길에서 쓰지 않는다. 이 자리 하나만 세운다.
- */
-export type BaselineAxis = 'testSpecification' | 'materialDefinition' | 'recipeDefinition';
-type Stand = (manager: EntityManager, domainId: string, at: Date, edition: string) => Promise<{
-    stood: number;
-    unreadable: {
-        name: string;
-        problem: string;
-    }[];
-}>;
-/** 차례가 있다 — 품목이 검사 명세를, 제조법이 품목을 이름으로 가리킨다(이름은 기준선과 무관하게 있다). */
-export declare const BASELINE_AXES: readonly {
-    axis: BaselineAxis;
-    stand: Stand;
-}[];
-export interface BaselineReport {
-    domain: string;
-    axis: BaselineAxis;
-    stood: number;
-    unreadable: {
-        name: string;
-        problem: string;
-    }[];
-    /** 이 축의 트랜잭션이 통째로 실패했다 — 그 도메인의 그 축은 아무것도 안 섰다. */
-    failed?: string;
-}
-/** 이 버전의 이름 — 기준선의 사유에 남는다. */
-export declare function baselineEdition(): string;
-/**
- * 기준선이 실패한 까닭을 **사람이 읽을 수 있게** — 코드만이 아니라 본문을 싣는다.
- *
- * 앞서는 `error.code` 가 있으면 그것만 적었다. SQLite 의 실패는 코드가 늘 `SQLITE_ERROR` 라 기동 로그에
- * 「MIRATEK · SYSTEM: SQLITE_ERROR」만 남았고, 무엇이 실패했는지(「transaction within a transaction」)는 어디에도
- * 없었다(2026-09-24). 교대 기준선도 이 함수로 적는다.
- */
-export declare function baselineFailureText(error: any): string;
-export declare function standMasterBaselines(dataSource: DataSource, options?: {
-    edition?: string;
-    domains?: Domain[];
-    axes?: readonly {
-        axis: BaselineAxis;
-        stand: Stand;
-    }[];
-}): Promise<BaselineReport[]>;
-/**
- * 기동 때 부른다. **서버를 반쯤 뜬 채로 두지 않는다** — 여기서 무엇이 실패해도 던지지 않고 말한다.
- * 한 도메인의 실패는 그 도메인만의 것이다.
- */
-export declare function standMasterBaselinesAtBoot(dataSource: DataSource): Promise<BaselineReport[]>;
-export {};