@simplysm/sd-cli 12.16.24 → 13.0.0-beta.11

package/src/pkg-builders/client/SdNgBundlerContext.ts

@@ -1,138 +0,0 @@
-import esbuild from "esbuild";
-import path from "path";
-import { SdLogger } from "@simplysm/sd-core-node";
-import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
-
-// import { InitialFileRecord } from "@angular/build/src/tools/esbuild/bundler-context";
-
-interface InitialFileRecord {
-  entrypoint: boolean;
-  name?: string;
-  type: "script" | "style";
-  external?: boolean;
-  serverFile: boolean;
-  depth: number;
-}
-
-export class SdNgBundlerContext {
-  private readonly _logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundlerContext"]);
-
-  private _context?: esbuild.BuildContext;
-
-  constructor(
-    private readonly _pkgPath: string,
-    private readonly _watch: boolean,
-    private readonly _esbuildOptions: esbuild.BuildOptions,
-  ) {}
-
-  async bundleAsync() {
-    let esbuildResult: esbuild.BuildResult;
-
-    this._debug(`Building...`);
-    if (this._watch) {
-      if (this._context == null) {
-        this._context = await esbuild.context(this._esbuildOptions);
-      }
-
-      try {
-        esbuildResult = await this._context.rebuild();
-      } catch (err) {
-        if ("warnings" in err || "errors" in err) {
-          esbuildResult = err;
-        } else {
-          throw err;
-        }
-      }
-    } else {
-      try {
-        esbuildResult = await esbuild.build(this._esbuildOptions);
-      } catch (err) {
-        if ("warnings" in err || "errors" in err) {
-          esbuildResult = err;
-        } else {
-          throw err;
-        }
-      }
-    }
-    this._debug(`Build completed`);
-
-    this._debug(`Converting results...`);
-    const results = SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(
-      esbuildResult,
-      this._pkgPath,
-    );
-
-    const initialFiles = new Map<string, InitialFileRecord>();
-
-    for (const outputFile of esbuildResult.outputFiles ?? []) {
-      const relativeFilePath = path.isAbsolute(outputFile.path)
-        ? path.relative(this._pkgPath, outputFile.path)
-        : outputFile.path;
-      const entryPoint = esbuildResult.metafile?.outputs[relativeFilePath]?.entryPoint;
-
-      outputFile.path = relativeFilePath;
-
-      if (entryPoint != null) {
-        const name = path.basename(relativeFilePath).split(".", 1)[0];
-        const type = path.extname(relativeFilePath) === ".css" ? "style" : "script";
-
-        if (this._esbuildOptions.entryPoints?.[name] != null) {
-          initialFiles.set(relativeFilePath, {
-            name,
-            type,
-            entrypoint: true,
-            serverFile: false,
-            depth: 0,
-          });
-        }
-      }
-    }
-
-    const files = [...initialFiles.keys()];
-    for (const file of files) {
-      const entryRecord = initialFiles.get(file)!;
-
-      for (const initialImport of esbuildResult.metafile?.outputs[file]?.imports ?? []) {
-        const existingRecord = initialFiles.get(initialImport.path);
-        if (existingRecord) {
-          if (existingRecord.depth > entryRecord.depth + 1) {
-            existingRecord.depth = entryRecord.depth + 1;
-          }
-          continue;
-        }
-
-        if (initialImport.kind === "import-statement" || initialImport.kind === "import-rule") {
-          const record: InitialFileRecord = {
-            type: initialImport.kind === "import-rule" ? "style" : "script",
-            entrypoint: false,
-            external: initialImport.external,
-            serverFile: false,
-            depth: entryRecord.depth + 1,
-          };
-
-          initialFiles.set(initialImport.path, record);
-
-          if (!initialImport.external) {
-            files.push(initialImport.path);
-          }
-        }
-      }
-    }
-
-    return {
-      results,
-      initialFiles,
-      outputFiles: esbuildResult.outputFiles,
-      metafile: esbuildResult.metafile,
-    };
-  }
-
-  private _debug(...msg: any[]): void {
-    this._logger.debug(
-      `[${path.basename(this._pkgPath)}] (${Object.keys(
-        this._esbuildOptions.entryPoints as Record<string, any>,
-      ).join(", ")})`,
-      ...msg,
-    );
-  }
-}

package/src/pkg-builders/client/createSdNgPlugin.ts

@@ -1,186 +0,0 @@
-import esbuild from "esbuild";
-import path from "path";
-import os from "os";
-import { JavaScriptTransformer } from "@angular/build/src/tools/esbuild/javascript-transformer";
-import { FsUtils, PathUtils, SdLogger, TNormPath } from "@simplysm/sd-core-node";
-import { SdCliPerformanceTimer } from "../../utils/SdCliPerformanceTimer";
-import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
-import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
-import { ISdCliNgPluginResultCache } from "../../types/plugin/ISdCliNgPluginResultCache";
-import { ISdTsCompilerResult } from "../../types/build/ISdTsCompilerResult";
-import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
-
-export function createSdNgPlugin(
-  opt: ISdTsCompilerOptions,
-  modifiedFileSet: Set<TNormPath>,
-  resultCache: ISdCliNgPluginResultCache,
-): esbuild.Plugin {
-  let perf: SdCliPerformanceTimer;
-  const logger = SdLogger.get(["simplysm", "sd-cli", "createSdNgPlugin"]);
-
-  const debug = (...msg: any[]) => {
-    logger.debug(`[${path.basename(opt.pkgPath)}]`, ...msg);
-  };
-
-  return {
-    name: "sd-ng-plugin",
-    setup: (build: esbuild.PluginBuild) => {
-      const tsCompiler = new SdTsCompiler(opt, true);
-
-      let tsCompileResult: ISdTsCompilerResult;
-      const outputContentsCacheMap = new Map<TNormPath, Uint8Array>();
-
-      //-- js babel transformer
-      const javascriptTransformer = new JavaScriptTransformer(
-        {
-          thirdPartySourcemaps: !!opt.watch?.dev,
-          sourcemap: !!opt.watch?.dev,
-          jit: false,
-          advancedOptimizations: !opt.watch?.dev,
-        },
-        Math.floor((os.cpus().length * 2) / 3),
-      );
-
-      //---------------------------
-
-      build.onStart(async () => {
-        perf = new SdCliPerformanceTimer("esbuild");
-
-        const res = await perf.run("typescript build", async () => {
-          for (const modifiedFile of modifiedFileSet) {
-            outputContentsCacheMap.delete(modifiedFile);
-          }
-
-          tsCompileResult = await tsCompiler.compileAsync(modifiedFileSet);
-
-          resultCache.watchFileSet = tsCompileResult.watchFileSet;
-          resultCache.affectedFileSet = tsCompileResult.affectedFileSet;
-
-          const tsEsbuildResult = SdCliConvertMessageUtils.convertToEsbuildFromBuildMessages(
-            tsCompileResult.messages,
-            opt.pkgPath,
-          );
-
-          //-- return err/warn
-          return {
-            errors: [
-              ...tsEsbuildResult.errors,
-              ...Array.from(tsCompileResult.stylesheetBundlingResultMap.values())
-                .flatMap((item) => item.errors)
-                .filterExists(),
-            ].filterExists(),
-            warnings: [
-              ...tsEsbuildResult.warnings,
-              ...Array.from(tsCompileResult.stylesheetBundlingResultMap.values())
-                .flatMap((item) => item.warnings)
-                .filterExists(),
-            ],
-          };
-        });
-
-        perf.start("esbuild transform & bundling");
-        return res;
-      });
-
-      build.onLoad({ filter: /\.ts$/ }, async (args) => {
-        const emittedFiles = tsCompileResult.emittedFilesCacheMap.get(PathUtils.norm(args.path));
-
-        const output = outputContentsCacheMap.get(PathUtils.norm(args.path));
-        if (output != null) {
-          return { contents: output, loader: "js" };
-        }
-
-        const contents = emittedFiles?.last()?.text ?? "";
-
-        const { sideEffects } = await build.resolve(args.path, {
-          kind: "import-statement",
-          resolveDir: build.initialOptions.absWorkingDir ?? "",
-        });
-
-        const newContents = await perf.run("esbuild transform:js:*.ts", async () => {
-          return await javascriptTransformer.transformData(args.path, contents, true, sideEffects);
-        });
-
-        outputContentsCacheMap.set(PathUtils.norm(args.path), newContents);
-
-        return { contents: newContents, loader: "js" };
-      });
-
-      build.onLoad({ filter: /\.mjs$/ }, async (args) => {
-        resultCache.watchFileSet!.add(PathUtils.norm(args.path));
-
-        const output = outputContentsCacheMap.get(PathUtils.norm(args.path));
-        if (output != null) {
-          return { contents: output, loader: "js" };
-        }
-
-        const { sideEffects } = await build.resolve(args.path, {
-          kind: "import-statement",
-          resolveDir: build.initialOptions.absWorkingDir ?? "",
-        });
-
-        try {
-          const newContents = await perf.run("esbuild transform:js:*.js", async () => {
-            const contents = await FsUtils.readFileBufferAsync(args.path);
-
-            return await javascriptTransformer.transformData(
-              args.path,
-              contents.toString(),
-              false,
-              sideEffects,
-            );
-          });
-
-          outputContentsCacheMap.set(PathUtils.norm(args.path), newContents);
-
-          return {
-            contents: newContents,
-            loader: "js",
-          };
-        } catch (err) {
-          return { errors: [{ text: err?.message ?? String(err) }] };
-        }
-      });
-
-      const otherLoaderFilter = new RegExp(
-        "(" +
-          Object.keys(build.initialOptions.loader ?? {})
-            .map((ext) => "\\" + ext)
-            .join("|") +
-          ")$",
-      );
-      build.onLoad({ filter: otherLoaderFilter }, (args) => {
-        resultCache.watchFileSet!.add(PathUtils.norm(args.path));
-        return null;
-      });
-
-      build.onEnd((result) => {
-        perf.end("esbuild transform & bundling");
-        debug(perf.toString());
-
-        for (const stylesheetBundlingResult of tsCompileResult.stylesheetBundlingResultMap.values()) {
-          if ("outputFiles" in stylesheetBundlingResult) {
-            result.outputFiles ??= [];
-            result.outputFiles.push(...stylesheetBundlingResult.outputFiles);
-
-            if (result.metafile) {
-              result.metafile.inputs = {
-                ...result.metafile.inputs,
-                ...stylesheetBundlingResult.metafile.inputs,
-              };
-              result.metafile.outputs = {
-                ...result.metafile.outputs,
-                ...stylesheetBundlingResult.metafile.outputs,
-              };
-            }
-          }
-        }
-
-        resultCache.outputFiles = result.outputFiles;
-        resultCache.metafile = result.metafile;
-
-        modifiedFileSet.clear();
-      });
-    },
-  };
-}

package/src/pkg-builders/commons/SdWorkerPathPlugin.ts

@@ -1,117 +0,0 @@
-import esbuild from "esbuild";
-import path from "path";
-import { FsUtils, HashUtils } from "@simplysm/sd-core-node";
-
-export function SdWorkerPathPlugin(outdir: string): esbuild.Plugin {
-  return {
-    name: "sd-worker-path-plugin",
-    setup(build) {
-      build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
-        const originalSource = await FsUtils.readFileAsync(args.path);
-
-        // 정규식: import.meta.resolve('...') 또는 "..." 캡쳐
-        // 워커 파일뿐만 아니라 필요한 모든 리소스를 처리할 수 있지만, 일단 worker만 타겟팅
-        const regex = /import\.meta\.resolve\(\s*(['"])([^'"]+?\.worker)(?:\.[a-z]+)?\1\s*\)/g;
-
-        if (!regex.test(originalSource)) {
-          return null;
-        }
-
-        // 매칭되는 모든 import.meta.resolve를 찾아서 처리
-        const newSource = await replaceAsync(
-          originalSource,
-          regex,
-          async (match, quote, relPath) => {
-            // 1. 실제 워커 파일 경로 계산
-            const workerSourcePath = path.resolve(path.dirname(args.path), relPath);
-
-            // 확장자가 없을 경우 자동 탐색 (js, ts 등)
-            const resolvedWorkerPath = resolveFile(workerSourcePath);
-            if (resolvedWorkerPath == null) {
-              // 파일이 없으면 건드리지 않음 (런타임 에러로 넘김)
-              return match;
-            }
-
-            // 2. 출력될 워커 파일명 결정 (캐싱 및 중복 방지를 위해 해시 사용 권장)
-            const fileContent = await FsUtils.readFileBufferAsync(resolvedWorkerPath);
-            const hash = HashUtils.get(fileContent).substring(0, 8);
-            const workerBaseName = path.basename(
-              resolvedWorkerPath,
-              path.extname(resolvedWorkerPath),
-            );
-            const outputFileName = `${workerBaseName}-${hash}.js`;
-            const outputFilePath = path.join(outdir, "workers", outputFileName);
-
-            // 3. 워커 파일 빌드 (존재하지 않거나 변경되었을 때만)
-            // (간단하게 하기 위해 매번 빌드 시도하거나, 해시로 체크 가능. 여기선 esbuild 증분 빌드에 맡김)
-            // *중요*: 워커도 번들링해야 함.
-            await esbuild.build({
-              ...build.initialOptions,
-              plugins:
-                build.initialOptions.plugins?.filter(
-                  (item) =>
-                    item.name !== "sd-worker-path-plugin" &&
-                    item.name !== "sd-ng-plugin" &&
-                    item.name !== "sd-server-plugin",
-                ) ?? [],
-              outdir: undefined,
-
-              entryPoints: [resolvedWorkerPath],
-              bundle: true,
-              write: true,
-              splitting: false,
-              outfile: outputFilePath,
-              // platform: build.initialOptions.platform,
-              // target: build.initialOptions.target,
-              // format: build.initialOptions.format,
-              // minify: build.initialOptions.minify,
-              // banner: build.initialOptions.banner,
-              // sourcemap: build.initialOptions.sourcemap,
-              // external: build.initialOptions.external, // 외부 의존성 설정 상속
-              // 플러그인 상속 주의: 무한 루프 방지를 위해 이 플러그인은 제외해야 함
-            });
-
-            // 4. 경로 치환
-            // 번들링된 메인 파일(dist/main.js) 기준으로 workers 폴더는 ./workers/ 임
-            return `import.meta.resolve(${quote}./workers/${outputFileName}${quote})`;
-          },
-        );
-
-        return {
-          contents: newSource,
-          loader: "ts", // 또는 js, 파일 확장자에 따라 다르게 처리 가능하나 보통 ts로 넘겨도 됨
-          // 워커 파일이 변경되면 이 파일도 다시 빌드되어야 함을 알림
-          // (정확히 하려면 워커의 의존성까지 다 넣어야 하지만, 최소한 워커 엔트리는 넣음)
-          // watchFiles: ... (esbuild가 내부적으로 처리해주길 기대)
-        };
-      });
-    },
-  };
-}
-
-// 정규식 비동기 replace 헬퍼
-async function replaceAsync(
-  str: string,
-  regex: RegExp,
-  asyncFn: (match: string, ...args: any[]) => Promise<string>,
-) {
-  const promises: Promise<string>[] = [];
-  str.replace(regex, (match, ...args) => {
-    promises.push(asyncFn(match, ...args));
-    return match;
-  });
-  const data = await Promise.all(promises);
-  return str.replace(regex, () => data.shift()!);
-}
-
-// 파일 확장자 찾기 헬퍼
-function resolveFile(filePathWithoutExt: string): string | undefined {
-  if (FsUtils.exists(filePathWithoutExt)) return filePathWithoutExt;
-
-  const exts = [".ts", ".js", ".mjs", ".cjs"];
-  for (const ext of exts) {
-    const p = filePathWithoutExt + ext;
-    if (FsUtils.exists(p)) return p;
-  }
-  return undefined;
-}

package/src/pkg-builders/lib/SdCliDbContextFileGenerator.ts

@@ -1,177 +0,0 @@
-import { FsUtils, HashUtils, PathUtils, SdFsWatcher } from "@simplysm/sd-core-node";
-import path from "path";
-import { StringUtils } from "@simplysm/sd-core-common";
-import { INpmConfig } from "../../types/common-config/INpmConfig";
-
-export class SdCliDbContextFileGenerator {
-  cachedHash?: string;
-
-  async watchAsync(pkgPath: string, kebabName: string) {
-    const targetFilePath = path.resolve(pkgPath, `src/${kebabName}.ts`);
-    this.cachedHash = FsUtils.exists(targetFilePath)
-      ? HashUtils.get(await FsUtils.readFileAsync(targetFilePath))
-      : undefined;
-
-    const watcher = await SdFsWatcher.watchAsync([path.resolve(pkgPath, "src")], {
-      ignored: [targetFilePath],
-    });
-    watcher.onChange({ delay: 50 }, async (changeInfos) => {
-      if (changeInfos.some((item) => ["add", "addDir", "unlink", "unlinkDir"].includes(item.event)))
-        await this.runAsync(pkgPath, kebabName);
-    });
-
-    await this.runAsync(pkgPath, kebabName);
-  }
-
-  async runAsync(
-    pkgPath: string,
-    kebabName: string,
-  ): Promise<{ changed: boolean; filePath: string; content: string }> {
-    const npmConfig = (await FsUtils.readJsonAsync(
-      path.resolve(pkgPath, "package.json"),
-    )) as INpmConfig;
-    const useExt = npmConfig.dependencies?.["@simplysm/sd-orm-common-ext"] != null;
-
-    const targetFilePath = path.resolve(pkgPath, `src/${kebabName}.ts`);
-
-    const importTexts: string[] = [];
-
-    if (useExt) {
-      importTexts.push('import { DbContextExt } from "@simplysm/sd-orm-common-ext";');
-    } else {
-      importTexts.push('import { DbContext } from "@simplysm/sd-orm-common";');
-    }
-
-    // Migrations
-    const migTexts: string[] = [];
-    {
-      const filePaths = await FsUtils.globAsync(path.resolve(pkgPath, "src/migrations/**/*.ts"), {
-        nodir: true,
-      });
-
-      for (const filePath of filePaths.orderBy()) {
-        const requirePath = PathUtils.posix(path.relative(path.dirname(targetFilePath), filePath))
-          .replace(/\.tsx?$/, "")
-          .replace(/\/index$/, "");
-        const fileName = path.basename(filePath, path.extname(filePath));
-
-        const className = fileName.includes("_") ? fileName : StringUtils.toPascalCase(fileName);
-
-        importTexts.push(`import { ${className} } from "./${requirePath}";`);
-        migTexts.push(className + ",");
-      }
-    }
-
-    // Models
-    const modelTexts: string[] = [];
-    {
-      const filePaths = await FsUtils.globAsync(path.resolve(pkgPath, "src/models/**/*.ts"), {
-        nodir: true,
-      });
-
-      for (const filePath of filePaths.orderBy()) {
-        const requirePath = PathUtils.posix(path.relative(path.dirname(targetFilePath), filePath))
-          .replace(/\.tsx?$/, "")
-          .replace(/\/index$/, "");
-        const fileName = path.basename(filePath, path.extname(filePath));
-
-        const varName = fileName.includes("_") ? fileName : StringUtils.toCamelCase(fileName);
-        const className = fileName.includes("_") ? fileName : StringUtils.toPascalCase(fileName);
-
-        importTexts.push(`import { ${className} } from "./${requirePath}";`);
-        if (
-          useExt &&
-          [
-            "systemDataLog",
-            "systemLog",
-            "authentication",
-            "user",
-            "userConfig",
-            "userPermission",
-          ].includes(varName)
-        ) {
-          modelTexts.push(`override ${varName} = new Queryable(this, ${className})`);
-        } else {
-          modelTexts.push(`${varName} = new Queryable(this, ${className})`);
-        }
-      }
-    }
-
-    // Views
-    const viewTexts: string[] = [];
-    {
-      const filePaths = await FsUtils.globAsync(path.resolve(pkgPath, "src/views/**/*.ts"), {
-        nodir: true,
-      });
-
-      for (const filePath of filePaths.orderBy()) {
-        const requirePath = PathUtils.posix(path.relative(path.dirname(targetFilePath), filePath))
-          .replace(/\.tsx?$/, "")
-          .replace(/\/index$/, "");
-        const fileName = path.basename(filePath, path.extname(filePath));
-
-        const varName = fileName.includes("_") ? fileName : StringUtils.toCamelCase(fileName);
-        const className = fileName.includes("_") ? fileName : StringUtils.toPascalCase(fileName);
-
-        importTexts.push(`import { ${className} } from "./${requirePath}";`);
-        viewTexts.push(`${varName} = new Queryable(this, ${className})`);
-      }
-    }
-
-    // Stored Procedures
-    const spTexts: string[] = [];
-    {
-      const filePaths = await FsUtils.globAsync(
-        path.resolve(pkgPath, "src/stored-procedures/**/*.ts"),
-        {
-          nodir: true,
-        },
-      );
-
-      for (const filePath of filePaths.orderBy()) {
-        const requirePath = PathUtils.posix(path.relative(path.dirname(targetFilePath), filePath))
-          .replace(/\.tsx?$/, "")
-          .replace(/\/index$/, "");
-        const fileName = path.basename(filePath, path.extname(filePath));
-
-        const varName = fileName.includes("_") ? fileName : StringUtils.toCamelCase(fileName);
-        const className = fileName.includes("_") ? fileName : StringUtils.toPascalCase(fileName);
-
-        importTexts.push(`import { ${className} } from "./${requirePath}";`);
-        spTexts.push(`${varName} = new StoredProcedure(this, ${className})`);
-      }
-    }
-
-    importTexts.push(
-      ...[
-        `import { IDbMigration${
-          modelTexts.length > 0 || viewTexts.length > 0 ? ", Queryable" : ""
-        }${spTexts.length > 0 ? ", StoredProcedure" : ""} } from "@simplysm/sd-orm-common";`,
-        'import { Type } from "@simplysm/sd-core-common";',
-      ],
-    );
-
-    const content = `
-${importTexts.join("\n")}
-
-export class ${StringUtils.toPascalCase(kebabName)} extends DbContext${useExt ? "Ext" : ""} {
-  get migrations(): Type<IDbMigration>[] {
-    return [
-${migTexts.map((item) => "    " + item).join("\n")}
-    ];
-  }
-${modelTexts.length > 0 ? "\n  // Models\n" + modelTexts.map((item) => "  " + item).join("\n") : ""}
-${viewTexts.length > 0 ? "\n  // Views\n" + viewTexts.map((item) => "  " + item).join("\n") : ""}
-${spTexts.length > 0 ? "\n  // StoredProcedures\n" + spTexts.map((item) => "  " + item).join("\n") : ""}
-}
-`.trim();
-    const currHash = HashUtils.get(content);
-    if (currHash !== this.cachedHash) {
-      await FsUtils.writeFileAsync(targetFilePath, content);
-      this.cachedHash = currHash;
-      return { changed: true, filePath: targetFilePath, content };
-    } else {
-      return { changed: false, filePath: targetFilePath, content };
-    }
-  }
-}