create-entity-app-server 0.0.3

package/src/app/schedules/data-retention/index.ts

@@ -0,0 +1,238 @@
+/**
+ * Data retention scheduler (anonymize / delete dormant accounts)
+ *
+ * Go internal/privacy/service.go dataRetentionLoop / runDataRetention porting.
+ *
+ * Flow:
+ *   1) croner cron (default daily 02:30)
+ *   2) distributed lock (privacy_cron_lock)
+ *   3) page dormant accounts (500/page)
+ *   4) if updated_time < retentionCutoff -> anonymize or hard-delete
+ *   5) clean up related records (account_oauth, user, password_history)
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+    entityServer,
+    logger,
+    createCron,
+    type CronHandle,
+} from "@gateway/api";
+import { acquireLock, releaseLock } from "@gateway/api";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/* ---- types ---- */
+
+interface RetentionConfig {
+    enabled: boolean;
+    retention_days: number;
+    action: "anonymize" | "delete";
+    cron: string;
+}
+
+interface AccountRow {
+    seq: number;
+    updated_time?: string;
+    status?: string;
+}
+
+/* ---- config ---- */
+
+function loadConfig(): RetentionConfig {
+    const configPath = resolve(__dirname, "config.json");
+    let raw: Record<string, unknown> = {};
+    if (existsSync(configPath)) {
+        try {
+            raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {
+            // use defaults
+        }
+    }
+    const action = String(raw.action || "anonymize");
+    return {
+        enabled: Boolean(raw.enabled),
+        retention_days: Number(raw.retention_days) || 1095,
+        action: action === "delete" ? "delete" : "anonymize",
+        cron: String(raw.cron || "30 2 * * *"),
+    };
+}
+
+/* ---- helpers ---- */
+
+const DAY_MS = 86_400_000;
+const LOCK_TTL_SEC = 86_400;
+
+async function deleteOAuthRecords(accountSeq: number): Promise<void> {
+    try {
+        const res = await entityServer.list("account_oauth", {
+            conditions: { account_seq: accountSeq },
+            limit: 100,
+        });
+        const items = (res?.data?.items ?? []) as Array<{ seq: number }>;
+        for (const item of items) {
+            await entityServer.delete("account_oauth", item.seq, {
+                hard: true,
+            });
+        }
+    } catch {
+        // ignore: entity may not exist
+    }
+}
+
+async function anonymizeUser(accountSeq: number): Promise<void> {
+    try {
+        const res = await entityServer.find("user", {
+            conditions: { account_seq: accountSeq },
+        });
+        const user = res?.data as { seq?: number } | null;
+        if (user?.seq) {
+            await entityServer.submit("user", {
+                seq: user.seq,
+                name: "탈퇴회원_" + user.seq,
+                profile_image: "",
+                status: "inactive",
+            });
+        }
+    } catch {
+        // ignore
+    }
+}
+
+async function deletePasswordHistory(accountSeq: number): Promise<void> {
+    try {
+        const res = await entityServer.list("password_history", {
+            conditions: { account_seq: accountSeq },
+            limit: 100,
+        });
+        const items = (res?.data?.items ?? []) as Array<{ seq: number }>;
+        for (const item of items) {
+            await entityServer.delete("password_history", item.seq, {
+                hard: true,
+            });
+        }
+    } catch {
+        // ignore
+    }
+}
+
+/* ---- main logic ---- */
+
+async function runDataRetention(cfg: RetentionConfig): Promise<number> {
+    const now = Date.now();
+    const cutoffMs = now - cfg.retention_days * DAY_MS;
+
+    let affected = 0;
+    const limit = 500;
+    let page = 1;
+
+    while (true) {
+        let items: AccountRow[];
+        let total: number;
+        try {
+            const res = await entityServer.list("account", {
+                conditions: { status: "dormant" },
+                page,
+                limit,
+            });
+            items = (res?.data?.items ?? []) as AccountRow[];
+            total = Number(res?.data?.total ?? 0);
+        } catch (err) {
+            logger.error(
+                { err },
+                "DataRetention: failed to list dormant accounts",
+            );
+            break;
+        }
+        if (!items.length) break;
+
+        for (const account of items) {
+            const seq = Number(account.seq);
+            if (!seq) continue;
+
+            // check dormant transition time (updated_time)
+            const dormantSince = account.updated_time;
+            if (!dormantSince) continue;
+
+            const dormantMs = Date.parse(dormantSince);
+            if (Number.isNaN(dormantMs)) continue;
+
+            // retention period not elapsed yet
+            if (dormantMs >= cutoffMs) continue;
+
+            try {
+                if (cfg.action === "delete") {
+                    await entityServer.delete("account", seq, { hard: true });
+                } else {
+                    // anonymize
+                    await entityServer.submit("account", {
+                        seq,
+                        email: "withdrawn_" + seq + "@anonymized.local",
+                        status: "inactive",
+                        passwd: "",
+                    });
+                }
+
+                // clean up related records
+                await deleteOAuthRecords(seq);
+                await anonymizeUser(seq);
+                await deletePasswordHistory(seq);
+
+                affected++;
+            } catch (err) {
+                logger.warn(
+                    { err, seq },
+                    "DataRetention: failed to process account",
+                );
+            }
+        }
+
+        if (page * limit >= total) break;
+        page++;
+    }
+
+    return affected;
+}
+
+/* ---- scheduler entry ---- */
+
+let cronHandle: CronHandle | null = null;
+
+export function start(): void {
+    const cfg = loadConfig();
+    if (!cfg.enabled) {
+        return;
+    }
+
+    const execute = async () => {
+        const locked = await acquireLock("privacy:retention", LOCK_TTL_SEC);
+        if (!locked) return;
+
+        try {
+            const count = await runDataRetention(cfg);
+            if (count > 0) {
+                logger.info(
+                    "Data retention completed: action=" +
+                        cfg.action +
+                        " affected=" +
+                        count,
+                );
+            }
+        } catch (err) {
+            logger.error({ err }, "Data retention batch failed");
+        } finally {
+            await releaseLock("privacy:retention", LOCK_TTL_SEC);
+        }
+    };
+
+    cronHandle = createCron({ expression: cfg.cron, onTick: execute });
+}
+
+export function stop(): void {
+    if (cronHandle) {
+        cronHandle.stop();
+        cronHandle = null;
+    }
+}

package/src/app/schedules/dormancy/config.json

@@ -0,0 +1,15 @@
+{
+    "_comment": "계정 휴면 정책 설정. enabled를 true로 설정하면 일정 기간 로그인하지 않은 계정을 휴면 처리하는 기능이 활성화됩니다.",
+    "enabled": true,
+    "dormancy_days": 365,
+    "warning_days": [30, 7],
+    "cron": "0 2 * * *",
+    "email_subject": "계정 휴면 예정 안내",
+    "email_template": "dormancy_warning",
+    "login_url": "",
+    "send_completed_email": false,
+    "completed_email_subject": "계정이 휴면 처리되었습니다",
+    "completed_email_template": "dormancy_completed",
+    "deploy": true,
+    "minify": false
+}

package/src/app/schedules/dormancy/entities/account.json

@@ -0,0 +1,14 @@
+{
+    "name": "account",
+    "description": "휴면 스케줄(dormancy) 전용 필드. dormancy 스케줄이 활성화될 때 account 엔티티에 추가됩니다.",
+    "fields": {
+        "dormancy_warned_days": {
+            "type": "uint",
+            "comment": "가장 최근에 발송한 휴면 경고 D-일수 (중복 발송 방지). 로그인 및 휴면 복귀 시 Go 서버에 의해 0으로 초기화됩니다."
+        },
+        "passwd_expiry_warned_days": {
+            "type": "uint",
+            "comment": "가장 최근에 발송한 비밀번호 만료 경고 D-일수 (중복 발송 방지). 비밀번호 변경 시 0으로 초기화됩니다."
+        }
+    }
+}

package/src/app/schedules/dormancy/entities/privacy_cron_lock.json

@@ -0,0 +1,23 @@
+{
+    "name": "privacy_cron_lock",
+    "description": "개인정보보호 배치 작업의 분산 락. 다중 인스턴스 환경에서 중복 실행을 방지합니다.",
+    "fields": {
+        "job_name": {
+            "type": "varchar(64)",
+            "required": true,
+            "unique": true,
+            "comment": "배치 작업 식별자 (e.g., dormancy:2024-01-15)"
+        },
+        "locked_by": {
+            "type": "varchar(128)",
+            "comment": "락을 획득한 인스턴스 식별자 (hostname:pid)"
+        },
+        "locked_time": {
+            "comment": "락 획득 시각"
+        },
+        "expires_time": {
+            "index": true,
+            "comment": "락 만료 시각 (이 시각 이후 stale lock으로 처리)"
+        }
+    }
+}

package/src/app/schedules/dormancy/index.ts

@@ -0,0 +1,289 @@
+/**
+ * Dormancy warning + transition scheduler
+ *
+ * Go internal/privacy/service.go dormancyLoop / runDormancyCycle porting.
+ *
+ * Flow:
+ *   1) croner cron (default daily 02:00)
+ *   2) distributed lock (privacy_cron_lock) for multi-instance dedup
+ *   3) page active accounts (500/page)
+ *   4) if last activity < dormancyCutoff -> transition to dormant
+ *   5) else check warningDays (descending) -> dedup (dormancy_warned_days) -> email
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+    entityServer,
+    logger,
+    sendEmail,
+    createCron,
+    ensurePluginEntities,
+    type CronHandle,
+} from "@gateway/api";
+import { acquireLock, releaseLock } from "@gateway/api";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/* ---- types ---- */
+
+interface DormancyConfig {
+    enabled: boolean;
+    dormancy_days: number;
+    warning_days: number[];
+    cron: string;
+    email_subject: string;
+    email_template: string;
+    login_url: string;
+    /** 휴면 전환 완료 시 안내 이메일 발송 여부 */
+    send_completed_email: boolean;
+    completed_email_subject: string;
+    completed_email_template: string;
+}
+
+interface AccountRow {
+    seq: number;
+    email?: string;
+    status?: string;
+    rbac_role?: string;
+    last_login_time?: string;
+    updated_time?: string;
+    created_time?: string;
+    dormancy_warned_days?: number;
+}
+
+/* ---- config ---- */
+
+function loadConfig(): DormancyConfig {
+    const configPath = resolve(__dirname, "config.json");
+    let raw: Record<string, unknown> = {};
+    if (existsSync(configPath)) {
+        try {
+            raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {
+            // use defaults
+        }
+    }
+    return {
+        enabled: Boolean(raw.enabled),
+        dormancy_days: Number(raw.dormancy_days) || 365,
+        warning_days: Array.isArray(raw.warning_days)
+            ? raw.warning_days.map(Number)
+            : [30, 7],
+        cron: String(raw.cron || "0 2 * * *"),
+        email_subject: String(raw.email_subject || "계정 휴면 예정 안내"),
+        email_template: String(raw.email_template || "dormancy_warning"),
+        login_url: String(raw.login_url || ""),
+        send_completed_email: Boolean(raw.send_completed_email),
+        completed_email_subject: String(
+            raw.completed_email_subject || "계정이 휴면 처리되었습니다",
+        ),
+        completed_email_template: String(
+            raw.completed_email_template || "dormancy_completed",
+        ),
+    };
+}
+
+/* ---- helpers ---- */
+
+const DAY_MS = 86_400_000;
+const LOCK_TTL_SEC = 86_400;
+
+function resolveLastActivityTime(account: AccountRow): string {
+    for (const field of [
+        "last_login_time",
+        "updated_time",
+        "created_time",
+    ] as const) {
+        const v = account[field];
+        if (v && String(v).trim()) return String(v).trim();
+    }
+    return "";
+}
+
+/* ---- main logic ---- */
+
+async function runDormancyCycle(
+    cfg: DormancyConfig,
+): Promise<{ warned: number; transitioned: number }> {
+    const now = Date.now();
+    const dormancyCutoffMs = now - cfg.dormancy_days * DAY_MS;
+    const warningDays = [...cfg.warning_days].sort((a, b) => b - a);
+
+    let warned = 0;
+    let transitioned = 0;
+    const limit = 500;
+    let page = 1;
+
+    while (true) {
+        let items: AccountRow[];
+        let total: number;
+        try {
+            const res = await entityServer.list("account", {
+                conditions: { status: "active" },
+                page,
+                limit,
+            });
+            items = (res?.data?.items ?? []) as AccountRow[];
+            total = Number(res?.data?.total ?? 0);
+        } catch (err) {
+            logger.error({ err }, "Dormancy: failed to list accounts");
+            break;
+        }
+        if (!items.length) break;
+
+        for (const account of items) {
+            // skip admin
+            if (account.rbac_role === "admin") continue;
+
+            const seq = Number(account.seq);
+            if (!seq) continue;
+
+            const lastTime = resolveLastActivityTime(account);
+            if (!lastTime) continue;
+
+            const lastMs = Date.parse(lastTime);
+            if (Number.isNaN(lastMs)) continue;
+
+            // Branch A: transition to dormant
+            if (lastMs < dormancyCutoffMs) {
+                try {
+                    await entityServer.submit("account", {
+                        seq,
+                        status: "dormant",
+                    });
+                    transitioned++;
+                } catch (err) {
+                    logger.warn(
+                        { err, seq },
+                        "Dormancy: failed to transition account",
+                    );
+                    continue;
+                }
+
+                // 휴면 전환 완료 안내 이메일
+                if (cfg.send_completed_email && account.email) {
+                    try {
+                        await sendEmail({
+                            to: [account.email],
+                            subject: cfg.completed_email_subject,
+                            templateDir: join(__dirname, "templates"),
+                            templateName: cfg.completed_email_template,
+                            templateData: {
+                                email: account.email,
+                                login_url: cfg.login_url || "#",
+                            },
+                        });
+                    } catch (err) {
+                        logger.warn(
+                            { err, email: account.email },
+                            "Dormancy: failed to send completed email",
+                        );
+                    }
+                }
+                continue;
+            }
+
+            // Branch B: warning email
+            const email = account.email;
+            if (!email) continue;
+
+            const daysSinceLast = Math.floor((now - lastMs) / DAY_MS);
+            const daysUntilDormancy = cfg.dormancy_days - daysSinceLast;
+            if (daysUntilDormancy < 0) continue;
+
+            const lastWarnedDays = Number(account.dormancy_warned_days) || 0;
+
+            for (const warnDay of warningDays) {
+                if (
+                    daysUntilDormancy <= warnDay &&
+                    lastWarnedDays !== warnDay
+                ) {
+                    // DB update first (dedup)
+                    try {
+                        await entityServer.submit("account", {
+                            seq,
+                            dormancy_warned_days: warnDay,
+                        });
+                    } catch {
+                        break;
+                    }
+                    // send email
+                    try {
+                        await sendEmail({
+                            to: [email],
+                            subject:
+                                cfg.email_subject +
+                                " (D-" +
+                                daysUntilDormancy +
+                                ")",
+                            templateDir: join(__dirname, "templates"),
+                            templateName: cfg.email_template,
+                            templateData: {
+                                email,
+                                days_left: String(daysUntilDormancy),
+                                login_url: cfg.login_url || "#",
+                            },
+                        });
+                    } catch (err) {
+                        logger.warn(
+                            { err, email },
+                            "Dormancy: failed to send warning",
+                        );
+                    }
+                    warned++;
+                    break;
+                }
+            }
+        }
+
+        if (page * limit >= total) break;
+        page++;
+    }
+
+    return { warned, transitioned };
+}
+
+/* ---- scheduler entry ---- */
+
+let cronHandle: CronHandle | null = null;
+
+export async function start(): Promise<void> {
+    const cfg = loadConfig();
+    if (!cfg.enabled) {
+        return;
+    }
+
+    await ensurePluginEntities(__dirname).catch((err) =>
+        logger.warn({ err }, "dormancy: ensureEntities failed"),
+    );
+
+    const execute = async () => {
+        const locked = await acquireLock("privacy:dormancy", LOCK_TTL_SEC);
+        if (!locked) return;
+
+        try {
+            const { warned, transitioned } = await runDormancyCycle(cfg);
+            if (warned > 0 || transitioned > 0) {
+                logger.info(
+                    { warned, transitioned },
+                    "Dormancy cycle completed",
+                );
+            }
+        } catch (err) {
+            logger.error({ err }, "Dormancy batch failed");
+        } finally {
+            await releaseLock("privacy:dormancy", LOCK_TTL_SEC);
+        }
+    };
+
+    cronHandle = createCron({ expression: cfg.cron, onTick: execute });
+}
+
+export function stop(): void {
+    if (cronHandle) {
+        cronHandle.stop();
+        cronHandle = null;
+    }
+}

package/src/app/schedules/dormancy/templates/dormancy_completed.html

@@ -0,0 +1,21 @@
+<h2 style="margin: 0 0 8px; font-size: 22px; font-weight: 700; color: #1a1a2e;">계정이 휴면 처리되었습니다</h2>
+<p style="margin: 0 0 24px; font-size: 13px; color: #999;">${email}</p>
+<p style="margin: 0 0 20px; font-size: 15px; color: #555; line-height: 1.6;">
+    안녕하세요.<br>
+    장기간 로그인 기록이 없어 <strong>${email}</strong> 계정이 <strong>휴면 상태</strong>로 전환되었습니다.
+</p>
+<div style="background-color: #f0f4ff; border-left: 4px solid #4f6ef7; border-radius: 4px; padding: 16px 20px; margin: 0 0 24px;">
+    <p style="margin: 0; font-size: 14px; color: #2d3a8c; line-height: 1.6;">
+        휴면 계정은 로그인 시 본인 확인 후 즉시 복구할 수 있습니다.<br>
+        개인정보 보호를 위해 일정 기간이 지나면 계정 정보가 삭제될 수 있습니다.
+    </p>
+</div>
+<p style="margin: 0 0 24px; font-size: 15px; color: #555; line-height: 1.6;">
+    계속 서비스를 이용하시려면 아래 버튼을 클릭해 로그인해 주세요.
+</p>
+<div style="text-align: center; margin: 0 0 28px;">
+    <a href="${login_url|#}" style="display: inline-block; padding: 14px 40px; background-color: #1a1a2e; color: #ffffff; text-decoration: none; border-radius: 6px; font-size: 15px; font-weight: 600;">로그인하여 계정 복구</a>
+</div>
+<p style="margin: 0; font-size: 13px; color: #aaa; line-height: 1.6;">
+    본인이 요청하지 않은 이메일이라면 무시하셔도 됩니다. 이 안내는 자동 발송된 이메일입니다.
+</p>

package/src/app/schedules/dormancy/templates/dormancy_warning.html

@@ -0,0 +1,20 @@
+<h2 style="margin: 0 0 8px; font-size: 22px; font-weight: 700; color: #1a1a2e;">계정 휴면 예정 안내</h2>
+<p style="margin: 0 0 24px; font-size: 13px; color: #999;">D-${days_left|30}</p>
+<p style="margin: 0 0 20px; font-size: 15px; color: #555; line-height: 1.6;">
+    안녕하세요.<br>
+    <strong>${email}</strong> 계정이 <strong>${days_left|30}일 후</strong> 장기 미접속으로 인해 휴면 상태로 전환될 예정입니다.
+</p>
+<div style="background-color: #fff8e1; border-left: 4px solid #f59e0b; border-radius: 4px; padding: 16px 20px; margin: 0 0 24px;">
+    <p style="margin: 0; font-size: 14px; color: #92400e; line-height: 1.6;">
+        휴면 계정은 로그인이 제한되며, 서비스 이용을 위해 별도의 본인 인증이 필요합니다.
+    </p>
+</div>
+<p style="margin: 0 0 24px; font-size: 15px; color: #555; line-height: 1.6;">
+    지금 로그인하면 휴면 전환을 방지할 수 있습니다.
+</p>
+<div style="text-align: center; margin: 0 0 28px;">
+    <a href="${login_url|#}" style="display: inline-block; padding: 14px 40px; background-color: #1a1a2e; color: #ffffff; text-decoration: none; border-radius: 6px; font-size: 15px; font-weight: 600;">지금 로그인하기</a>
+</div>
+<p style="margin: 0; font-size: 13px; color: #aaa; line-height: 1.6;">
+    이미 최근에 로그인하셨다면 이 안내는 무시하셔도 됩니다.
+</p>

package/src/app/schedules/kobc_freight_sync/config.json

@@ -0,0 +1,4 @@
+{
+    "enabled": true,
+    "cron": "0 6 * * *"
+}