@nestia/sdk 12.0.0-dev.20260601.1 → 12.0.0-dev.20260612.2

package/src/generates/internal/SdkTypeTagProgrammer.ts

@@ -1,114 +1,114 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import { LiteralFactory } from "@nestia/factory";
-import { IMetadataTypeTag } from "@typia/interface";
-
-import { ImportDictionary } from "./ImportDictionary";
-
-export namespace SdkTypeTagProgrammer {
-  export const write = (
-    importer: ImportDictionary,
-    from: "object" | "array" | "boolean" | "number" | "bigint" | "string",
-    tag: IMetadataTypeTag,
-  ) => {
-    const name: string = tag.name.split("<")[0]!;
-    if (PREDEFINED[from]?.has(name) === true)
-      return TypeScriptFactory.createTypeReferenceNode(
-        TypeScriptFactory.createQualifiedName(
-          TypeScriptFactory.createIdentifier(
-            importer.external({
-              declaration: true,
-              file: `typia`,
-              type: "element",
-              name: "tags",
-            }),
-          ),
-          TypeScriptFactory.createIdentifier(name),
-        ),
-        [
-          TypeScriptFactory.createLiteralTypeNode(
-            LiteralFactory.write(tag.value) as any,
-          ),
-        ],
-      );
-    return TypeScriptFactory.createTypeReferenceNode(
-      TypeScriptFactory.createQualifiedName(
-        TypeScriptFactory.createIdentifier(
-          importer.external({
-            declaration: true,
-            file: `typia`,
-            type: "element",
-            name: "tags",
-          }),
-        ),
-        TypeScriptFactory.createIdentifier("TagBase"),
-      ),
-      [
-        TypeScriptFactory.createLiteralTypeNode(
-          LiteralFactory.write({
-            target: from,
-            kind: tag.kind,
-            value: tag.value,
-            validate: tag.validate,
-            exclusive: tag.exclusive,
-            schema: tag.schema,
-          }) as any,
-        ),
-      ],
-    );
-  };
-}
-
-const COMMON_KINDS = ["Default", "Example", "Examples", "Sequence"];
-const PREDEFINED = {
-  object: new Set([...COMMON_KINDS]),
-  array: new Set([...COMMON_KINDS, "MinItems", "MaxItems", "UniqueItems"]),
-  boolean: new Set([...COMMON_KINDS]),
-  number: new Set([
-    ...COMMON_KINDS,
-    "Minimum",
-    "Maximum",
-    "ExclusiveMinimum",
-    "ExclusiveMaximum",
-    "MultipleOf",
-    "Type",
-  ]),
-  bigint: new Set([
-    ...COMMON_KINDS,
-    "Minimum",
-    "Maximum",
-    "ExclusiveMinimum",
-    "ExclusiveMaximum",
-    "MultipleOf",
-    "Type",
-  ]),
-  string: new Set([
-    ...COMMON_KINDS,
-    "ContentMediaType",
-    "Format",
-    "MaxLength",
-    "MinLength",
-    "Pattern",
-  ]),
-};
-
-// export * from "./Constant";
-// export * from "./ContentMediaType";
-// export * from "./Default";
-// export * from "./Example";
-// export * from "./Examples";
-// export * from "./ExclusiveMaximum";
-// export * from "./ExclusiveMinimum";
-// export * from "./Format";
-// export * from "./JsonSchemaPlugin";
-// export * from "./Maximum";
-// export * from "./MaxItems";
-// export * from "./MaxLength";
-// export * from "./Minimum";
-// export * from "./MinItems";
-// export * from "./MinLength";
-// export * from "./MultipleOf";
-// export * from "./Pattern";
-// export * from "./Sequence";
-// export * from "./TagBase";
-// export * from "./Type";
-// export * from "./UniqueItems";
+import { TypeScriptFactory } from "@nestia/factory";
+import { LiteralFactory } from "@nestia/factory";
+import { IMetadataTypeTag } from "@typia/interface";
+
+import { ImportDictionary } from "./ImportDictionary";
+
+export namespace SdkTypeTagProgrammer {
+  export const write = (
+    importer: ImportDictionary,
+    from: "object" | "array" | "boolean" | "number" | "bigint" | "string",
+    tag: IMetadataTypeTag,
+  ) => {
+    const name: string = tag.name.split("<")[0]!;
+    if (PREDEFINED[from]?.has(name) === true)
+      return TypeScriptFactory.createTypeReferenceNode(
+        TypeScriptFactory.createQualifiedName(
+          TypeScriptFactory.createIdentifier(
+            importer.external({
+              declaration: true,
+              file: `typia`,
+              type: "element",
+              name: "tags",
+            }),
+          ),
+          TypeScriptFactory.createIdentifier(name),
+        ),
+        [
+          TypeScriptFactory.createLiteralTypeNode(
+            LiteralFactory.write(tag.value) as any,
+          ),
+        ],
+      );
+    return TypeScriptFactory.createTypeReferenceNode(
+      TypeScriptFactory.createQualifiedName(
+        TypeScriptFactory.createIdentifier(
+          importer.external({
+            declaration: true,
+            file: `typia`,
+            type: "element",
+            name: "tags",
+          }),
+        ),
+        TypeScriptFactory.createIdentifier("TagBase"),
+      ),
+      [
+        TypeScriptFactory.createLiteralTypeNode(
+          LiteralFactory.write({
+            target: from,
+            kind: tag.kind,
+            value: tag.value,
+            validate: tag.validate,
+            exclusive: tag.exclusive,
+            schema: tag.schema,
+          }) as any,
+        ),
+      ],
+    );
+  };
+}
+
+const COMMON_KINDS = ["Default", "Example", "Examples", "Sequence"];
+const PREDEFINED = {
+  object: new Set([...COMMON_KINDS]),
+  array: new Set([...COMMON_KINDS, "MinItems", "MaxItems", "UniqueItems"]),
+  boolean: new Set([...COMMON_KINDS]),
+  number: new Set([
+    ...COMMON_KINDS,
+    "Minimum",
+    "Maximum",
+    "ExclusiveMinimum",
+    "ExclusiveMaximum",
+    "MultipleOf",
+    "Type",
+  ]),
+  bigint: new Set([
+    ...COMMON_KINDS,
+    "Minimum",
+    "Maximum",
+    "ExclusiveMinimum",
+    "ExclusiveMaximum",
+    "MultipleOf",
+    "Type",
+  ]),
+  string: new Set([
+    ...COMMON_KINDS,
+    "ContentMediaType",
+    "Format",
+    "MaxLength",
+    "MinLength",
+    "Pattern",
+  ]),
+};
+
+// export * from "./Constant";
+// export * from "./ContentMediaType";
+// export * from "./Default";
+// export * from "./Example";
+// export * from "./Examples";
+// export * from "./ExclusiveMaximum";
+// export * from "./ExclusiveMinimum";
+// export * from "./Format";
+// export * from "./JsonSchemaPlugin";
+// export * from "./Maximum";
+// export * from "./MaxItems";
+// export * from "./MaxLength";
+// export * from "./Minimum";
+// export * from "./MinItems";
+// export * from "./MinLength";
+// export * from "./MultipleOf";
+// export * from "./Pattern";
+// export * from "./Sequence";
+// export * from "./TagBase";
+// export * from "./Type";
+// export * from "./UniqueItems";

package/src/generates/internal/SdkWebSocketCloneProgrammer.ts

@@ -0,0 +1,319 @@
+import fs from "fs";
+import path from "path";
+
+import { ITypedApplication } from "../../structures/ITypedApplication";
+
+export namespace SdkWebSocketCloneProgrammer {
+  export const write = async (app: ITypedApplication): Promise<Set<string>> => {
+    const ctx: IContext = {
+      output: `${app.project.config.output}/structures`,
+      outputs: new Map(),
+      visited: new Map(),
+    };
+    const cloned: Set<string> = new Set();
+    for (const route of app.routes)
+      if (route.protocol === "websocket")
+        for (const imp of route.imports)
+          for (const name of imp.elements) {
+            if (await clone(ctx)(imp.file, name))
+              cloned.add(importKey(imp.file, name));
+          }
+    return cloned;
+  };
+
+  const clone =
+    (ctx: IContext) =>
+    async (file: string, name: string): Promise<boolean> => {
+      const location: string | null = await resolveSourceFile(file);
+      if (location === null || isNodeModulesPath(location)) return false;
+
+      const key: string = `${location}#${name}`;
+      const status: CloneStatus | undefined = ctx.visited.get(key);
+      if (status === "written" || status === "pending") return true;
+      else if (status === "missing") return false;
+      ctx.visited.set(key, "pending");
+
+      const text: string = await fs.promises.readFile(location, "utf8");
+      const declarations: string[] = getDeclarations(text, name);
+      if (declarations.length === 0) {
+        ctx.visited.set(key, "missing");
+        return false;
+      }
+
+      const body: string = declarations.join("\n\n");
+      const imports: string[] = await collectImports(ctx)({
+        body,
+        location,
+        source: text,
+        target: name,
+      });
+
+      const content: string =
+        [...imports, body].filter((line) => line.length).join("\n\n") + "\n";
+      const oldbie: string | undefined = ctx.outputs.get(name);
+      if (oldbie !== undefined && oldbie !== content) {
+        ctx.visited.set(key, "missing");
+        return false;
+      }
+      ctx.outputs.set(name, content);
+
+      await fs.promises.mkdir(ctx.output, { recursive: true });
+      await fs.promises.writeFile(`${ctx.output}/${name}.ts`, content, "utf8");
+      ctx.visited.set(key, "written");
+      return true;
+    };
+
+  const collectImports =
+    (ctx: IContext) =>
+    async (props: {
+      body: string;
+      location: string;
+      source: string;
+      target: string;
+    }): Promise<string[]> => {
+      const imports: string[] = [];
+      const add = (line: string): void => {
+        if (imports.includes(line) === false) imports.push(line);
+      };
+
+      for (const imp of getImports(props.source)) {
+        const relative: boolean = imp.specifier.startsWith(".");
+        for (const elem of imp.elements) {
+          if (uses(props.body, elem.local) === false) continue;
+
+          if (relative === false) {
+            add(imp.text);
+            continue;
+          }
+
+          const sourceFile: string = path.resolve(
+            path.dirname(props.location),
+            imp.specifier,
+          );
+          if ((await clone(ctx)(sourceFile, elem.imported)) === false) {
+            add(imp.text);
+            continue;
+          }
+          add(
+            `import type { ${elem.imported}${elem.imported === elem.local ? "" : ` as ${elem.local}`} } from "./${elem.imported}";`,
+          );
+        }
+        for (const name of [imp.default, imp.namespace])
+          if (name !== null && uses(props.body, name)) add(imp.text);
+      }
+
+      for (const name of getExportedNames(props.source)) {
+        if (name === null || name === props.target) continue;
+        if (uses(props.body, name) === false) continue;
+        if ((await clone(ctx)(props.location, name)) === true)
+          add(`import type { ${name} } from "./${name}";`);
+      }
+      return imports.sort();
+    };
+
+  const resolveSourceFile = async (file: string): Promise<string | null> => {
+    const base: string = trimRuntimeExtension(file);
+    const candidates: string[] = [
+      file,
+      base,
+      `${base}.ts`,
+      `${base}.tsx`,
+      `${base}.d.ts`,
+      path.join(base, "index.ts"),
+      path.join(base, "index.d.ts"),
+    ];
+    for (const candidate of candidates) {
+      try {
+        const location: string = path.resolve(candidate);
+        const stat: fs.Stats = await fs.promises.stat(location);
+        if (stat.isFile()) return location;
+      } catch {}
+    }
+    return null;
+  };
+
+  const trimRuntimeExtension = (file: string): string => {
+    for (const ext of [".js", ".jsx", ".mjs", ".cjs"])
+      if (file.endsWith(ext)) return file.slice(0, -ext.length);
+    return file;
+  };
+
+  const getDeclarations = (source: string, name: string): string[] => {
+    const output: string[] = [];
+    const searchable: string = maskTrivia(source);
+    const regex: RegExp = declarationRegex(name);
+    for (const match of searchable.matchAll(regex)) {
+      if (isTopLevel(searchable, match.index!) === false) continue;
+      const end: number = declarationEnd(searchable, match.index!, match[1]!);
+      if (end !== -1) output.push(source.slice(match.index!, end).trim());
+    }
+    return output;
+  };
+
+  const getExportedNames = (source: string): string[] => {
+    const searchable: string = maskTrivia(source);
+    return Array.from(
+      searchable.matchAll(declarationRegex("[A-Za-z_$][\\w$]*")),
+    )
+      .filter((match) => isTopLevel(searchable, match.index!))
+      .map((match) => match[2]!);
+  };
+
+  const declarationRegex = (name: string): RegExp =>
+    new RegExp(
+      `export\\s+(?:declare\\s+)?(interface|type|enum|namespace|class)\\s+(${name})\\b`,
+      "g",
+    );
+
+  const declarationEnd = (
+    source: string,
+    start: number,
+    kind: string,
+  ): number => {
+    let depth: number = 0;
+    let block: boolean = false;
+    for (let i = start; i < source.length; ++i) {
+      const ch: string = source[i]!;
+      if (ch === "{") {
+        ++depth;
+        block = true;
+      } else if (ch === "}") {
+        --depth;
+        if (kind !== "type" && block && depth === 0) return i + 1;
+      } else if (ch === ";" && block === false && depth === 0) return i + 1;
+      else if (ch === ";" && kind === "type" && depth === 0) return i + 1;
+    }
+    return -1;
+  };
+
+  const isTopLevel = (source: string, index: number): boolean => {
+    let depth: number = 0;
+    for (let i = 0; i < index; ++i) {
+      const ch: string = source[i]!;
+      if (ch === "{") ++depth;
+      else if (ch === "}") --depth;
+    }
+    return depth === 0;
+  };
+
+  const maskTrivia = (source: string): string => {
+    const out: string[] = source.split("");
+    const mask = (index: number): void => {
+      if (out[index] !== "\n" && out[index] !== "\r") out[index] = " ";
+    };
+
+    let quote: string | null = null;
+    let escaped: boolean = false;
+    for (let i = 0; i < out.length; ++i) {
+      const ch: string = source[i]!;
+      const next: string | undefined = source[i + 1];
+      if (quote !== null) {
+        mask(i);
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === quote) quote = null;
+      } else if (ch === "/" && next === "/") {
+        mask(i++);
+        for (; i < out.length && source[i] !== "\n"; ++i) mask(i);
+        --i;
+      } else if (ch === "/" && next === "*") {
+        mask(i++);
+        mask(i);
+        for (++i; i < out.length; ++i) {
+          const current: string = source[i]!;
+          const following: string | undefined = source[i + 1];
+          mask(i);
+          if (current === "*" && following === "/") {
+            mask(++i);
+            break;
+          }
+        }
+      } else if (ch === '"' || ch === "'" || ch === "`") {
+        quote = ch;
+        mask(i);
+      }
+    }
+    return out.join("");
+  };
+
+  const getImports = (source: string): IImport[] =>
+    Array.from(
+      source.matchAll(/import\s+([\s\S]*?)\s+from\s+["']([^"']+)["'];?/g),
+    ).map((match) => {
+      const clause: string = match[1]!.trim();
+      const specifier: string = match[2]!;
+      return {
+        text: match[0]!.trim(),
+        specifier,
+        default: defaultImportName(clause),
+        namespace: namespaceImportName(clause),
+        elements: namedImportElements(clause),
+      };
+    });
+
+  const defaultImportName = (clause: string): string | null => {
+    const first: string = clause
+      .split(",")[0]!
+      .trim()
+      .replace(/^type\s+/, "");
+    return first.length && first.startsWith("{") === false ? first : null;
+  };
+
+  const namespaceImportName = (clause: string): string | null => {
+    const match: RegExpMatchArray | null = clause.match(/\*\s+as\s+(\w+)/);
+    return match?.[1] ?? null;
+  };
+
+  const namedImportElements = (clause: string): IImportElement[] => {
+    const match: RegExpMatchArray | null = clause.match(/\{([\s\S]*?)\}/);
+    if (match === null) return [];
+    return match[1]!
+      .split(",")
+      .map((part) => part.trim().replace(/^type\s+/, ""))
+      .filter((part) => part.length)
+      .map((part) => {
+        const pieces: string[] = part.split(/\s+as\s+/);
+        const imported: string = pieces[0]!.trim();
+        return {
+          imported,
+          local: (pieces[1] ?? imported).trim(),
+        };
+      });
+  };
+
+  const uses = (body: string, name: string): boolean =>
+    new RegExp(`\\b${escapeRegExp(name)}\\b`).test(body);
+
+  const escapeRegExp = (str: string): string =>
+    str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+  export const importKey = (file: string, name: string): string =>
+    `${file}#${name}`;
+
+  export const isNodeModulesPath = (file: string): boolean =>
+    path
+      .resolve(file)
+      .split(/[\\/]+/)
+      .includes("node_modules");
+}
+
+interface IContext {
+  output: string;
+  outputs: Map<string, string>;
+  visited: Map<string, CloneStatus>;
+}
+
+type CloneStatus = "pending" | "written" | "missing";
+
+interface IImport {
+  text: string;
+  specifier: string;
+  default: string | null;
+  namespace: string | null;
+  elements: IImportElement[];
+}
+
+interface IImportElement {
+  imported: string;
+  local: string;
+}