@gent-js/gent 0.1.8 → 0.1.10

package/dist/generated/packageEnv.d.ts

@@ -1,6 +1,6 @@
 export declare const packageEnv: {
     readonly fullName: "@gent-js/gent";
     readonly name: "gent";
-    readonly version: "0.1.8";
+    readonly version: "0.1.10";
     readonly description: "template-based data generator.";
 };

package/dist/generated/packageEnv.js

@@ -2,6 +2,6 @@
 export const packageEnv = {
     fullName: "@gent-js/gent",
     name: "gent",
-    version: "0.1.8",
+    version: "0.1.10",
     description: "template-based data generator."
 };

package/dist/src/cli.js

@@ -14,7 +14,7 @@ const outOption = new Option("-o --out <path>", "path to output files.").default
 const debugOption = new Option("-d --debug", "debug flat")
     .default(false)
     .hideHelp(true);
-async function main() {
+function main() {
     const program = new Command();
     program
         .name(packageEnv.name)
@@ -41,7 +41,9 @@ async function main() {
         if (meta !== undefined) {
             const resolvedFilePath = parseAndResolveFilePath(meta, cwd);
             if (resolvedFilePath === undefined) {
-                program.error(`failed to resolve meta file path.(${meta})`);
+                program.error(`failed to resolve meta file path.(${meta})`, {
+                    exitCode: FAILED,
+                });
                 return;
             }
             let fileContent;
@@ -52,7 +54,7 @@ async function main() {
                 console.log(error);
             }
             if (fileContent === undefined) {
-                program.error("failed to read meta file.");
+                program.error("failed to read meta file.", { exitCode: FAILED });
                 return;
             }
             try {
@@ -63,7 +65,7 @@ async function main() {
                 rawProgramOptions = undefined;
             }
             if (rawProgramOptions === undefined) {
-                program.error("failed to parse meta file.");
+                program.error("failed to parse meta file.", { exitCode: FAILED });
                 return;
             }
         }
@@ -97,6 +99,8 @@ async function main() {
             program.error("Command has failed", { exitCode: resultCode });
         }
     });
-    await program.parseAsync(process.argv);
+    program.parseAsync(process.argv).catch((error) => {
+        console.error(error);
+    });
 }
-await main();
+main();

package/dist/src/consts.d.ts

@@ -1,8 +1,8 @@
 import type { NonTransparentFramingMethod, TcpFramingMethod } from "./types.js";
 export declare const DEFAULT_TEMPLATE_WEIGHT = 1;
 export declare const TemplateModes: readonly ["text", "json"];
-export declare const NetworkOutputTypes: readonly ["udp", "tcp"];
-export declare const OutputTypes: readonly ["file", "udp", "tcp"];
+export declare const NetworkOutputTypes: readonly ["udp", "tcp", "tls"];
+export declare const OutputTypes: readonly ["file", "udp", "tcp", "tls"];
 export declare const DefaultEps = 3000;
 export declare const MaxEps: number;
 export declare const OctetCounting: "octet-counting";

package/dist/src/consts.js

@@ -1,6 +1,6 @@
 export const DEFAULT_TEMPLATE_WEIGHT = 1;
 export const TemplateModes = ["text", "json"];
-export const NetworkOutputTypes = ["udp", "tcp"];
+export const NetworkOutputTypes = ["udp", "tcp", "tls"];
 export const OutputTypes = ["file", ...NetworkOutputTypes];
 export const DefaultEps = 3000;
 export const MaxEps = Number.MAX_SAFE_INTEGER;

package/dist/src/output/createFileOutput.d.ts

@@ -1,2 +1,3 @@
 import * as stream from "node:stream";
-export declare function createFileOutput(nonRotateOutputPath: string, rotateSize: string | undefined, rotateOutputPathGenerator: (additionalPhrase: string) => string): Promise<stream.Writable>;
+import type { RotateOutputPathGenerator } from "./types.js";
+export declare function createFileOutput(nonRotateOutputPath: string, rotateSize: string | undefined, rotateOutputPathGenerator: RotateOutputPathGenerator): Promise<stream.Writable>;

package/dist/src/output/createTlsOutput.d.ts

@@ -0,0 +1,3 @@
+import * as stream from "node:stream";
+import type { TlsOutputOptions } from "../types.js";
+export declare function createTlsOutput(outputOptions: TlsOutputOptions): Promise<stream.Writable>;

package/dist/src/output/createTlsOutput.js

@@ -0,0 +1,13 @@
+import * as tls from "node:tls";
+export async function createTlsOutput(outputOptions) {
+    const tlsOptions = {
+        host: outputOptions.address,
+        port: outputOptions.port,
+        rejectUnauthorized: false,
+        // key: fs.readFileSync(path.join(__dirname, 'client-key.pem')),
+        // cert: fs.readFileSync(path.join(__dirname, 'client-cert.pem')),
+        // ca: [fs.readFileSync(path.join(__dirname, 'ca-cert.pem'))]
+    };
+    const client = tls.connect(tlsOptions);
+    return client;
+}

package/dist/src/output/initializeOutput.js

@@ -4,21 +4,29 @@ import * as nodePath from "node:path";
 import { assertNever } from "../utils.js";
 import { createFileOutput } from "./createFileOutput.js";
 import { createTcpOutput } from "./createTcpOutput.js";
+import { createTlsOutput } from "./createTlsOutput.js";
 import { UdpDocumentStream } from "./udpDocumentStream.js";
 export async function initializeOutput(outputOptions) {
     // region clean dir
-    const nonRotateOutputPath = outputOptions.path;
-    const parsed = nodePath.parse(outputOptions.path);
-    const rotateOutputPathGenerator = (additionalPhrase) => {
-        const filename = `${parsed.name}.${additionalPhrase}${parsed.ext}`;
-        return nodePath.join(parsed.dir, filename);
-    };
-    const nonRotateOutputGlobPath = nonRotateOutputPath.replaceAll("\\", "/");
-    const rotateOutputGlobPath = rotateOutputPathGenerator("*").replaceAll("\\", "/");
-    await cleanOutputDir(nonRotateOutputGlobPath, rotateOutputGlobPath);
+    const outputPath = outputOptions.path;
+    let rotateOutputPathGenerator;
+    if (outputPath !== undefined) {
+        // when output path is specified, clean dir.
+        const parsed = nodePath.parse(outputPath);
+        rotateOutputPathGenerator = (additionalPhrase) => {
+            const filename = `${parsed.name}.${additionalPhrase}${parsed.ext}`;
+            return nodePath.join(parsed.dir, filename);
+        };
+        const nonRotateOutputGlobPath = outputPath.replaceAll("\\", "/");
+        const rotateOutputGlobPath = rotateOutputPathGenerator("*").replaceAll("\\", "/");
+        await cleanOutputDir(nonRotateOutputGlobPath, rotateOutputGlobPath);
+    }
     // endregion
     if (outputOptions.type === "file") {
-        return createFileOutput(nonRotateOutputPath, outputOptions.size, rotateOutputPathGenerator);
+        if (rotateOutputPathGenerator === undefined) {
+            throw new Error("rotateOutputPathGenerator should be initialized at this point.");
+        }
+        return createFileOutput(outputOptions.path, outputOptions.size, rotateOutputPathGenerator);
     }
     else if (outputOptions.type === "udp") {
         return new UdpDocumentStream(outputOptions);
@@ -26,6 +34,9 @@ export async function initializeOutput(outputOptions) {
     else if (outputOptions.type === "tcp") {
         return createTcpOutput(outputOptions);
     }
+    else if (outputOptions.type === "tls") {
+        return createTlsOutput(outputOptions);
+    }
     else {
         return assertNever(outputOptions);
     }

package/dist/src/output/types.d.ts

@@ -0,0 +1,3 @@
+export interface RotateOutputPathGenerator {
+    (additionalPhrase: string): string;
+}

package/dist/src/output/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/run.js

@@ -8,45 +8,48 @@ import { MaxEps, TrailerMap } from "./consts.js";
 import { createDocumentFeeder } from "./createDocumentFeeder.js";
 import { createGeneratingDocumentStream } from "./createGeneratingDocumentStream.js";
 import { debugFileWriter } from "./debugFileWriter.js";
-import { initializeOutput } from "./output/initializeOutput.js";
 import { DocumentTransformStream } from "./documentTransformStream.js";
+import { initializeOutput } from "./output/initializeOutput.js";
 import "./command/commands/index.js";
 export async function run(programOptions) {
     const { debug, count, out, templates } = programOptions;
     // region out path
     const outPath = out.path;
-    const outDirPath = nodePath.dirname(outPath);
-    let existsOutDir = false;
-    try {
-        const stats = await fsPromises.stat(outDirPath);
-        if (stats.isDirectory()) {
-            existsOutDir = true;
+    if (outPath !== undefined) {
+        // check permissions on out path when specified.
+        const outDirPath = nodePath.dirname(outPath);
+        let existsOutDir = false;
+        try {
+            const stats = await fsPromises.stat(outDirPath);
+            if (stats.isDirectory()) {
+                existsOutDir = true;
+            }
+            await fsPromises.access(outDirPath, fs.constants.W_OK);
+        }
+        catch (error) {
+            existsOutDir = false;
+        }
+        if (!existsOutDir) {
+            try {
+                await fsPromises.mkdir(outDirPath, { recursive: true });
+            }
+            catch (error) {
+                console.error(`failed to create out path directory. ${outDirPath}`);
+                console.log(error);
+                return FAILED;
+            }
         }
-        await fsPromises.access(outDirPath, fs.constants.W_OK);
-    }
-    catch (error) {
-        existsOutDir = false;
-    }
-    if (!existsOutDir) {
         try {
-            await fsPromises.mkdir(outDirPath, { recursive: true });
+            await fsPromises.access(outDirPath, fs.constants.W_OK);
         }
         catch (error) {
-            console.error(`failed to create out path directory. ${outDirPath}`);
+            console.error(`cannot access out directory. ${outDirPath}`);
             console.log(error);
             return FAILED;
         }
-    }
-    try {
-        await fsPromises.access(outDirPath, fs.constants.W_OK);
-    }
-    catch (error) {
-        console.error(`cannot access out directory. ${outDirPath}`);
-        console.log(error);
-        return FAILED;
-    }
-    if (debug) {
-        debugFileWriter.setBaseDirectory(outDirPath);
+        if (debug) {
+            debugFileWriter.setBaseDirectory(outDirPath);
+        }
     }
     // endregion
     const documentFeeder = await createDocumentFeeder(templates, programOptions, commandManager);
@@ -67,7 +70,7 @@ export async function run(programOptions) {
             eps: out.eps,
         };
     }
-    else if (out.type === "tcp") {
+    else if (out.type === "tcp" || out.type === "tls") {
         if (out.framing === "octet-counting") {
             documentTransformOptions = {
                 transformMode: "buffer",

package/dist/src/types.d.ts

@@ -29,16 +29,17 @@ export interface TemplateOptions {
     readonly weight: number;
 }
 export type ShorthandOutputOptions = string;
-export type OutputOptions = FileOutputOptions | UdpOutputOptions | TcpOutputOptions;
+export type OutputOptions = FileOutputOptions | UdpOutputOptions | TcpOutputOptions | TlsOutputOptions;
 export type OutputType = (typeof OutputTypes)[number];
 export type NetworkOutputType = (typeof NetworkOutputTypes)[number];
 interface PrimitiveOutputOptions {
     readonly type: OutputType;
-    readonly path: string;
+    readonly path?: string | undefined;
 }
 export interface FileOutputOptions extends PrimitiveOutputOptions {
     readonly type: "file";
-    readonly size?: string;
+    readonly path: string;
+    readonly size?: string | undefined;
 }
 interface NetworkOutputOptions extends PrimitiveOutputOptions {
     readonly type: NetworkOutputType;
@@ -56,13 +57,23 @@ interface PrimitiveTcpOutputOptions extends NetworkOutputOptions {
     readonly framing: TcpFramingMethod;
 }
 interface TcpOctetCountingOutputOptions extends PrimitiveTcpOutputOptions {
-    readonly type: "tcp";
     readonly framing: "octet-counting";
 }
 interface TcpNonFramingOutputOptions extends PrimitiveTcpOutputOptions {
-    readonly type: "tcp";
     readonly framing: NonTransparentFramingMethod;
     readonly trailerReplacer: string;
 }
 export type TcpOutputOptions = TcpOctetCountingOutputOptions | TcpNonFramingOutputOptions;
+interface PrimitiveTlsOutputOptions extends NetworkOutputOptions {
+    readonly type: "tls";
+    readonly framing: TcpFramingMethod;
+}
+interface TlsOctetCountingOutputOptions extends PrimitiveTlsOutputOptions {
+    readonly framing: "octet-counting";
+}
+interface TlsNonFramingOutputOptions extends PrimitiveTlsOutputOptions {
+    readonly framing: NonTransparentFramingMethod;
+    readonly trailerReplacer: string;
+}
+export type TlsOutputOptions = TlsOctetCountingOutputOptions | TlsNonFramingOutputOptions;
 export {};

package/dist/src/utils.js

@@ -207,25 +207,17 @@ function normalizeOutputOptions(possibleOutputOptions, basePath) {
         return undefined;
     }
     const possiblePath = parseAndResolveFilePath(possibleOutputOptions["path"], basePath);
-    if (possiblePath === undefined) {
-        console.error(`output path must be specified.(${possiblePath})`);
-        return undefined;
-    }
     if (possibleType == "file") {
-        const possibleSize = parseString(possibleOutputOptions["size"]);
-        if (possibleSize === undefined) {
-            return {
-                type: possibleType,
-                path: possiblePath,
-            };
-        }
-        else {
-            return {
-                type: possibleType,
-                path: possiblePath,
-                size: possibleSize,
-            };
+        if (possiblePath === undefined) {
+            console.error(`output path must be specified.(${possiblePath})`);
+            return undefined;
         }
+        const possibleSize = parseString(possibleOutputOptions["size"]);
+        return {
+            type: possibleType,
+            path: possiblePath,
+            size: possibleSize,
+        };
     }
     else if (isNetworkOutputType(possibleType)) {
         const possibleAddress = parseString(possibleOutputOptions["address"]);
@@ -244,7 +236,7 @@ function normalizeOutputOptions(possibleOutputOptions, basePath) {
                 eps: possibleEps,
             };
         }
-        else if (possibleType === "tcp") {
+        else if (possibleType === "tcp" || possibleType === "tls") {
             const possibleFraming = parseString(possibleOutputOptions["framing"]) ??
                 DefaultTcpFramingMethod;
             if (!isTcpFramingType(possibleFraming)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gent-js/gent",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "template-based data generator.",
   "keywords": [
     "gent"