@simplysm/sd-cli 13.0.99 → 14.0.1

package/templates/init/packages/server/src/services/AuthService.ts.hbs

@@ -1,171 +0,0 @@
-import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
-import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
-import { expr } from "@simplysm/orm-common";
-import { MainDbContext, type MainDbContext as MainDbContextType } from "@{{projectName}}/db-main";
-import bcrypt from "bcrypt";
-
-export interface IAuthData {
-  employeeId: number;
-  employeeName: string;
-  email: string;
-  permissions: Record<string, boolean>;
-}
-
-export interface IAuthResult extends IAuthData {
-  token: string;
-}
-
-export const AuthService = defineService("AuthService", (ctx) => {
-  async function getOrm() {
-    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
-
-    return createOrm(MainDbContext, ormConfig.default);
-  }
-
-  async function getPermissions(
-    db: MainDbContextType,
-    roleId: number | undefined,
-  ): Promise<Record<string, boolean>> {
-    const permissions: Record<string, boolean> = {};
-
-    if (roleId != null) {
-      const rolePermissions = await db
-        .rolePermission()
-        .where((c) => [expr.eq(c.roleId, roleId)])
-        .result();
-
-      for (const rp of rolePermissions) {
-        permissions[rp.code] = JSON.parse(rp.valueJson);
-      }
-    }
-
-    return permissions;
-  }
-
-  async function buildAuthResult(
-    employee: { id: number; name: string; email: string | undefined },
-    permissions: Record<string, boolean>,
-  ): Promise<IAuthResult> {
-    const authData: IAuthData = {
-      employeeId: employee.id,
-      employeeName: employee.name,
-      email: employee.email ?? "",
-      permissions,
-    };
-
-    const token = await ctx.server.generateAuthToken({
-      roles: [],
-      data: authData,
-    });
-
-    return { token, ...authData };
-  }
-
-  function validateLoginInput(email: string, password: string): void {
-    if (email.length === 0 || email.length > 200) {
-      throw new Error("이메일은 1~200자의 문자열이어야 합니다.");
-    }
-    if (password.length === 0 || password.length > 500) {
-      throw new Error("비밀번호는 1~500자의 문자열이어야 합니다.");
-    }
-  }
-
-  return {
-    login: async (email: string, password: string): Promise<IAuthResult> => {
-      const orm = await getOrm();
-      validateLoginInput(email, password);
-
-      return orm.connect(async (db) => {
-        const employee = await db
-          .employee()
-          .where((c) => [expr.eq(c.email, email), expr.eq(c.isDeleted, false)])
-          .single();
-
-        if (!employee) {
-          throw new Error("이메일 또는 비밀번호가 올바르지 않습니다.");
-        }
-
-        if (employee.encryptedPassword == null || employee.encryptedPassword === "") {
-          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
-        }
-
-        const isValid = await bcrypt.compare(password, employee.encryptedPassword);
-        if (!isValid) {
-          throw new Error("이메일 또는 비밀번호가 올바르지 않습니다.");
-        }
-
-        const permissions = await getPermissions(db, employee.roleId);
-
-        return buildAuthResult(employee, permissions);
-      });
-    },
-
-    refresh: auth(async (): Promise<IAuthResult> => {
-      const currentAuth = ctx.authInfo as IAuthData | undefined;
-      if (!currentAuth) {
-        throw new Error("인증 정보가 없습니다.");
-      }
-
-      const orm = await getOrm();
-
-      return orm.connect(async (db) => {
-        const employee = await db
-          .employee()
-          .where((c) => [expr.eq(c.id, currentAuth.employeeId), expr.eq(c.isDeleted, false)])
-          .single();
-
-        if (!employee) {
-          throw new Error("유효하지 않은 직원입니다.");
-        }
-
-        const permissions = await getPermissions(db, employee.roleId);
-
-        return buildAuthResult(employee, permissions);
-      });
-    }),
-
-    changePassword: auth(async (currentPassword: string, newPassword: string): Promise<void> => {
-      const currentAuth = ctx.authInfo as IAuthData | undefined;
-      if (!currentAuth) {
-        throw new Error("인증 정보가 없습니다.");
-      }
-
-      validateLoginInput(currentAuth.email, currentPassword);
-      validateLoginInput(currentAuth.email, newPassword);
-
-      if (newPassword.length < 8) {
-        throw new Error("새 비밀번호는 최소 8자 이상이어야 합니다.");
-      }
-
-      const orm = await getOrm();
-
-      await orm.connect(async (db) => {
-        const employee = await db
-          .employee()
-          .where((c) => [expr.eq(c.id, currentAuth.employeeId), expr.eq(c.isDeleted, false)])
-          .single();
-
-        if (!employee) {
-          throw new Error("유효하지 않은 직원입니다.");
-        }
-
-        if (employee.encryptedPassword == null || employee.encryptedPassword === "") {
-          throw new Error("비밀번호가 설정되지 않은 계정입니다.");
-        }
-
-        const isCurrentValid = await bcrypt.compare(currentPassword, employee.encryptedPassword);
-        if (!isCurrentValid) {
-          throw new Error("현재 비밀번호가 올바르지 않습니다.");
-        }
-
-        const encryptedPassword = await bcrypt.hash(newPassword, 10);
-        await db
-          .employee()
-          .where((c) => [expr.eq(c.id, employee.id)])
-          .update(() => ({ encryptedPassword: expr.val("string", encryptedPassword) }));
-      });
-    }),
-  };
-});
-
-export type AuthServiceMethods = ServiceMethods<typeof AuthService>;

package/templates/init/packages/server/src/services/DevService.ts.hbs

@@ -1,94 +0,0 @@
-import { defineService, type ServiceMethods } from "@simplysm/service-server";
-import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
-import { MainDbContext } from "@{{projectName}}/db-main";
-import { ExcelWorkbook } from "@simplysm/excel";
-import bcrypt from "bcrypt";
-import fs from "fs";
-import path from "path";
-
-export const DevService = defineService("DevService", (ctx) => {
-  async function getOrm() {
-    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
-    return createOrm(MainDbContext, ormConfig.default);
-  }
-
-  return {
-    initDb: async (permCodes: string[]) => {
-      const orm = await getOrm();
-
-      await orm.connectWithoutTransaction(async (db) => {
-        await db.initialize({ force: true });
-
-        const excelPath = path.resolve(ctx.server.options.rootPath, "dev/초기화.xlsx");
-        if (!fs.existsSync(excelPath)) {
-          throw new Error(`초기화 파일을 찾을 수 없습니다: ${excelPath}`);
-        }
-
-        const buffer = fs.readFileSync(excelPath);
-        const wb = new ExcelWorkbook(buffer);
-        const wsNames = await wb.getWorksheetNames();
-
-        // Role
-        if (wsNames.includes("권한그룹")) {
-          const ws = await wb.getWorksheet("권한그룹");
-          const rows = await ws.getDataTable();
-          const filtered = rows.filter((r: Record<string, any>) => r["ID"] != null);
-          if (filtered.length > 0) {
-            await db.role().insert(
-              filtered.map((r: Record<string, any>) => ({
-                id: Number(r["ID"]),
-                name: String(r["명칭"]),
-              })),
-            );
-          }
-        }
-
-        // RolePermission
-        if (wsNames.includes("권한그룹권한")) {
-          const ws = await wb.getWorksheet("권한그룹권한");
-          const rows = await ws.getDataTable();
-          const filtered = rows.filter((r: Record<string, any>) => r["권한그룹.ID"] != null);
-          if (filtered.length > 0) {
-            const permRows = filtered.flatMap((r: Record<string, any>) => {
-              const roleId = Number(r["권한그룹.ID"]);
-              const code = String(r["코드"]);
-              const valueJson = String(r["값"]);
-
-              if (code === "ALL") {
-                return permCodes.map((pc) => ({ roleId, code: pc, valueJson }));
-              }
-              return [{ roleId, code, valueJson }];
-            });
-
-            await db.rolePermission().insert(permRows);
-          }
-        }
-
-        // Employee (bcrypt hash passwords)
-        if (wsNames.includes("직원")) {
-          const ws = await wb.getWorksheet("직원");
-          const rows = await ws.getDataTable();
-          const filtered = rows.filter((r: Record<string, any>) => r["ID"] != null);
-          if (filtered.length > 0) {
-            const employees = [];
-            for (const r of filtered) {
-              const pw = r["비밀번호"];
-              employees.push({
-                id: Number(r["ID"]),
-                name: String(r["이름"]),
-                email: r["이메일"] != null ? String(r["이메일"]) : undefined,
-                encryptedPassword:
-                  pw != null && String(pw) !== "" ? await bcrypt.hash(String(pw), 10) : undefined,
-                roleId: r["권한그룹.ID"] != null ? Number(r["권한그룹.ID"]) : undefined,
-                isDeleted: Boolean(r["삭제"]),
-              });
-            }
-            await db.employee().insert(employees);
-          }
-        }
-      });
-    },
-  };
-});
-
-export type DevServiceMethods = ServiceMethods<typeof DevService>;

package/templates/init/packages/server/src/services/EmployeeService.ts.hbs

@@ -1,122 +0,0 @@
-import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
-import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
-import { expr } from "@simplysm/orm-common";
-import { MainDbContext } from "@{{projectName}}/db-main";
-import { DateOnly, strIsNullOrEmpty } from "@simplysm/core-common";
-import bcrypt from "bcrypt";
-import type { IAuthData } from "./AuthService";
-
-export const EmployeeService = defineService("EmployeeService", (ctx) => {
-  async function getOrm() {
-    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
-    return createOrm(MainDbContext, ormConfig.default);
-  }
-
-  return {
-    save: auth(
-      async (
-        items: {
-          id?: number;
-          name?: string;
-          email?: string;
-          phoneNumber?: string;
-          birthDate?: DateOnly;
-          enteringDate?: DateOnly;
-          leavingDate?: DateOnly;
-          socialSecurityNumber?: string;
-          payrollAccountBank?: string;
-          payrollAccountNumber?: string;
-          password?: string;
-          isDeleted: boolean;
-        }[],
-      ): Promise<number[]> => {
-        const authData = ctx.authInfo as IAuthData | undefined;
-        if (authData?.permissions["/home/base/employee/edit"] !== true) {
-          throw new Error("저장 권한이 없습니다.");
-        }
-
-        const ids: number[] = [];
-        const orm = await getOrm();
-        await orm.connect(async (db) => {
-          for (const item of items) {
-            if (
-              !item.isDeleted &&
-              !strIsNullOrEmpty(item.name) &&
-              (await db
-                .employee()
-                .where((c) => [
-                  expr.not(expr.eq(c.id, item.id)),
-                  expr.eq(c.isDeleted, false),
-                  expr.eq(c.name, item.name),
-                ])
-                .exists())
-            ) {
-              throw new Error(`동일한 이름이 이미 등록되어 있습니다: ${item.name}`);
-            }
-
-            if (
-              !item.isDeleted &&
-              !strIsNullOrEmpty(item.email) &&
-              (await db
-                .employee()
-                .where((c) => [
-                  expr.not(expr.eq(c.id, item.id)),
-                  expr.eq(c.isDeleted, false),
-                  expr.eq(c.email, item.email),
-                ])
-                .exists())
-            ) {
-              throw new Error(`동일한 이메일이 이미 등록되어 있습니다: ${item.email}`);
-            }
-
-            const passwordObj =
-              authData.permissions["/home/base/employee/auth/edit"] &&
-              !strIsNullOrEmpty(item.password)
-                ? { encryptedPassword: await bcrypt.hash(item.password, 10) }
-                : {};
-
-            const upsertedId = (
-              await db
-                .employee()
-                .where((c) => [expr.eq(c.id, item.id)])
-                .upsert(
-                  () => ({
-                    name: item.name,
-                    email: item.email,
-                    phoneNumber: item.phoneNumber,
-                    birthDate: item.birthDate,
-                    enteringDate: item.enteringDate,
-                    leavingDate: item.leavingDate,
-                    isDeleted: item.isDeleted,
-                    ...(authData.permissions["/home/base/employee/personal/edit"]
-                      ? { socialSecurityNumber: item.socialSecurityNumber }
-                      : {}),
-                    ...(authData.permissions["/home/base/employee/payroll/edit"]
-                      ? {
-                          payrollAccountBank: item.payrollAccountBank,
-                          payrollAccountNumber: item.payrollAccountNumber,
-                        }
-                      : {}),
-                    ...passwordObj,
-                  }),
-                  ["id"],
-                )
-            ).single()?.id;
-
-            if (upsertedId != null) {
-              ids.push(upsertedId);
-              await db.employee().insertDataLog({
-                action: item.id == null ? "등록" : "수정",
-                itemId: upsertedId,
-                employeeId: authData.employeeId,
-              });
-            }
-          }
-        });
-        return ids;
-      },
-    ),
-  };
-});
-
-export type EmployeeServiceMethods = ServiceMethods<typeof EmployeeService>;

package/templates/init/packages/server/src/services/RoleService.ts.hbs

@@ -1,59 +0,0 @@
-import { auth, defineService, type ServiceMethods } from "@simplysm/service-server";
-import { createOrm, type DbConnConfig } from "@simplysm/orm-node";
-import { expr } from "@simplysm/orm-common";
-import { MainDbContext } from "@{{projectName}}/db-main";
-import { strIsNullOrEmpty } from "@simplysm/core-common";
-import type { IAuthData } from "./AuthService";
-
-export const RoleService = defineService("RoleService", (ctx) => {
-  async function getOrm() {
-    const ormConfig = await ctx.getConfig<{ default: DbConnConfig }>("orm");
-    return createOrm(MainDbContext, ormConfig.default);
-  }
-
-  return {
-    save: auth(
-      async (
-        items: {
-          id?: number;
-          name?: string;
-        }[],
-      ): Promise<void> => {
-        const authData = ctx.authInfo as IAuthData | undefined;
-        if (authData?.permissions["/home/base/role-permission/edit"] !== true) {
-          throw new Error("저장 권한이 없습니다.");
-        }
-
-        const orm = await getOrm();
-        await orm.connect(async (db) => {
-          for (const item of items) {
-            if (
-              !strIsNullOrEmpty(item.name) &&
-              (await db
-                .role()
-                .where((c) => [
-                  expr.not(expr.eq(c.id, item.id)),
-                  expr.eq(c.name, item.name),
-                ])
-                .exists())
-            ) {
-              throw new Error(`이미 존재하는 권한그룹 이름입니다: ${item.name}`);
-            }
-
-            await db
-              .role()
-              .where((c) => [expr.eq(c.id, item.id)])
-              .upsert(
-                () => ({
-                  name: item.name ?? "",
-                }),
-                ["id"],
-              );
-          }
-        });
-      },
-    ),
-  };
-});
-
-export type RoleServiceMethods = ServiceMethods<typeof RoleService>;

package/templates/init/pnpm-workspace.yaml

@@ -1,15 +0,0 @@
-packages:
-  - packages/*
-  - tests/*
-
-onlyBuiltDependencies:
-  - "@simplysm/sd-claude"
-  - bcrypt
-  - bufferutil
-  - core-js
-  - cpu-features
-  - esbuild
-  - sharp
-  - ssh2
-  - unrs-resolver
-  - utf-8-validate

package/templates/init/sd.config.ts.hbs

@@ -1,48 +0,0 @@
-import type { SdConfigFn } from "@simplysm/sd-cli";
-
-const dbPort = Number(process.env["DB_PORT"] ?? 5432);
-const dbDatabase = process.env["DB_DATABASE"] ?? "{{projectName}}";
-
-const config: SdConfigFn = ({ dev }) => ({
-  replaceDeps: {
-    "@simplysm/*": "../simplysm/packages/*",
-  },
-  packages: {
-    "db-main": { target: "neutral" },
-    "client-admin": {
-      target: "client",
-      server: "server",
-    },
-    "server": {
-      target: "server",
-      packageManager: "volta",
-      pm2: {},
-      configs: {
-        orm: {
-          default: dev
-            ? {
-                dialect: "postgresql",
-                host: "localhost",
-                port: dbPort,
-                username: "postgres",
-                password: "1234",
-                database: dbDatabase,
-              }
-            : {
-                dialect: "postgresql",
-                host: "localhost",
-                port: 5432,
-                username: "postgres",
-                password: "TODO",
-                database: "{{projectName}}",
-              },
-        },
-        auth: {
-          jwtSecret: "{{jwtSecret}}",
-        },
-      },
-    },
-  },
-});
-
-export default config;

package/templates/init/tsconfig.json.hbs

@@ -1,39 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "lib": ["ESNext", "DOM", "DOM.Iterable", "WebWorker"],
-    "moduleResolution": "bundler",
-    "jsx": "preserve",
-    "jsxImportSource": "solid-js",
-    "strict": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noImplicitAny": true,
-    "noFallthroughCasesInSwitch": true,
-    "useUnknownInCatchVariables": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "forceConsistentCasingInFileNames": true,
-    "useDefineForClassFields": true,
-    "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "importHelpers": true,
-    "baseUrl": ".",
-    "paths": {
-      "@{{projectName}}/*": ["packages/*/src/index.ts"]
-    }
-  },
-  "include": [
-    "*.ts",
-    "packages/*/*.ts",
-    "packages/*/src/**/*.ts",
-    "packages/*/src/**/*.tsx",
-    "packages/*/tests/**/*.ts",
-    "packages/*/tests/**/*.tsx",
-    "tests/**/*.ts"
-  ]
-}

package/templates/init/vitest.config.ts

@@ -1,36 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-  plugins: [
-    tsconfigPaths({
-      root: __dirname,
-      projects: ["./tsconfig.json"],
-    }),
-  ],
-  define: {
-    "process.env.DEV": JSON.stringify("true"),
-    "process.env.VER": JSON.stringify("1.0.0-test"),
-  },
-  test: {
-    globals: true,
-    environment: "node",
-    coverage: {
-      reportsDirectory: "./.coverage",
-    },
-    projects: [
-      {
-        extends: true,
-        test: {
-          name: "node",
-          include: ["packages/*/tests/**/*.spec.{ts,tsx,js}"],
-          testTimeout: 30000,
-        },
-      },
-    ],
-  },
-});

package/tests/capacitor-exclude.spec.ts

@@ -1,78 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { mockWriteJson, mockReadJson, mockExists } = vi.hoisted(() => ({
-  mockWriteJson: vi.fn().mockResolvedValue(undefined),
-  mockReadJson: vi.fn(),
-  mockExists: vi.fn(),
-}));
-
-vi.mock("@simplysm/core-node", () => ({
-  fsx: {
-    readJson: mockReadJson,
-    exists: mockExists,
-    mkdir: vi.fn().mockResolvedValue(undefined),
-    writeJson: mockWriteJson,
-    write: vi.fn().mockResolvedValue(undefined),
-  },
-}));
-
-vi.mock("consola", () => {
-  const withTag = () => ({ debug: vi.fn(), warn: vi.fn() });
-  const consola = { withTag };
-  return { default: consola, consola };
-});
-
-vi.mock("sharp", () => ({ default: vi.fn() }));
-vi.mock("execa", () => ({ execa: vi.fn() }));
-
-import { Capacitor } from "../src/capacitor/capacitor";
-
-describe("Capacitor exclude packages", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockReadJson.mockImplementation((filePath: string) => {
-      if (filePath.includes(".capacitor")) {
-        return Promise.resolve({ name: "", version: "", dependencies: {} });
-      }
-      return Promise.resolve({
-        name: "@test/app",
-        version: "1.0.0",
-        dependencies: { "jeep-sqlite": "^0.0.1" },
-      });
-    });
-    mockExists.mockImplementation((filePath: string) => {
-      if (filePath.endsWith("package.json")) return Promise.resolve(true);
-      return Promise.resolve(false);
-    });
-  });
-
-  it("exclude 패키지가 .capacitor/package.json dependencies에 추가된다", async () => {
-    const cap = await Capacitor.create("/test/packages/app", {
-      appId: "com.test.app",
-      appName: "Test App",
-    }, ["jeep-sqlite"]);
-
-    await (cap as unknown as { _setupNpmConf(): Promise<boolean> })._setupNpmConf();
-
-    expect(mockWriteJson).toHaveBeenCalled();
-    const writtenConfig = mockWriteJson.mock.calls[0][1] as {
-      dependencies: Record<string, string>;
-    };
-    expect(writtenConfig.dependencies["jeep-sqlite"]).toBe("^0.0.1");
-  });
-
-  it("exclude 없이 생성해도 정상 동작한다", async () => {
-    const cap = await Capacitor.create("/test/packages/app", {
-      appId: "com.test.app",
-      appName: "Test App",
-    });
-
-    await (cap as unknown as { _setupNpmConf(): Promise<boolean> })._setupNpmConf();
-
-    expect(mockWriteJson).toHaveBeenCalled();
-    const writtenConfig = mockWriteJson.mock.calls[0][1] as {
-      dependencies: Record<string, string>;
-    };
-    expect(writtenConfig.dependencies["jeep-sqlite"]).toBeUndefined();
-  });
-});