@sourceregistry/node-ovsdb 1.0.1 → 1.0.3

package/dist-cli/cli.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const generator_1 = require("./generator");
+/**
+ * Runs the OVSDB type generation CLI.
+ */
+async function runCli(argv) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        process.stdout.write(getHelpText());
+        return 0;
+    }
+    if (!args.schemaPath && !args.socketPath && !args.host) {
+        process.stderr.write("Missing input. Provide --schema <file>, --socket <path>, or --host <name>.\n");
+        process.stderr.write(getHelpText());
+        return 1;
+    }
+    if (!args.stdout && !args.outputPath) {
+        process.stderr.write("Missing destination. Provide --out <file> or use --stdout.\n");
+        process.stderr.write(getHelpText());
+        return 1;
+    }
+    try {
+        const outputPath = args.outputPath ? (0, node_path_1.resolve)(args.outputPath) : undefined;
+        if (outputPath) {
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(outputPath), { recursive: true });
+        }
+        const generated = await (0, generator_1.generateTypesFile)({
+            schemaPath: args.schemaPath ? (0, node_path_1.resolve)(args.schemaPath) : undefined,
+            socketPath: args.socketPath,
+            host: args.host,
+            port: args.port,
+            tls: args.tls,
+            tlsInsecure: args.tlsInsecure,
+            tlsServername: args.tlsServername,
+            tlsCaFile: args.tlsCaFile ? (0, node_path_1.resolve)(args.tlsCaFile) : undefined,
+            tlsCertFile: args.tlsCertFile ? (0, node_path_1.resolve)(args.tlsCertFile) : undefined,
+            tlsKeyFile: args.tlsKeyFile ? (0, node_path_1.resolve)(args.tlsKeyFile) : undefined,
+            databaseName: args.databaseName,
+            outputPath,
+            databaseTypeName: args.databaseTypeName,
+            importFrom: args.importFrom
+        });
+        if (args.stdout) {
+            process.stdout.write(generated);
+        }
+        else if (outputPath) {
+            process.stdout.write(`Generated TypeScript types at ${outputPath}\n`);
+        }
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(`${formatError(error)}\n`);
+        return 1;
+    }
+}
+function parseArgs(argv) {
+    const parsed = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        switch (arg) {
+            case "--schema":
+                parsed.schemaPath = requireValue(argv, ++index, arg);
+                break;
+            case "--socket":
+                parsed.socketPath = requireValue(argv, ++index, arg);
+                break;
+            case "--host":
+                parsed.host = requireValue(argv, ++index, arg);
+                break;
+            case "--port":
+                parsed.port = Number.parseInt(requireValue(argv, ++index, arg), 10);
+                if (Number.isNaN(parsed.port)) {
+                    throw new Error("Expected --port to be a number");
+                }
+                break;
+            case "--db":
+            case "--database":
+                parsed.databaseName = requireValue(argv, ++index, arg);
+                break;
+            case "--tls":
+                parsed.tls = true;
+                break;
+            case "--tls-insecure":
+                parsed.tlsInsecure = true;
+                break;
+            case "--tls-servername":
+                parsed.tlsServername = requireValue(argv, ++index, arg);
+                break;
+            case "--tls-ca-file":
+                parsed.tlsCaFile = requireValue(argv, ++index, arg);
+                break;
+            case "--tls-cert-file":
+                parsed.tlsCertFile = requireValue(argv, ++index, arg);
+                break;
+            case "--tls-key-file":
+                parsed.tlsKeyFile = requireValue(argv, ++index, arg);
+                break;
+            case "--out":
+            case "--output":
+                parsed.outputPath = requireValue(argv, ++index, arg);
+                break;
+            case "--name":
+                parsed.databaseTypeName = requireValue(argv, ++index, arg);
+                break;
+            case "--import-from":
+                parsed.importFrom = requireValue(argv, ++index, arg);
+                break;
+            case "--stdout":
+                parsed.stdout = true;
+                break;
+            case "--help":
+            case "-h":
+                parsed.help = true;
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return parsed;
+}
+function requireValue(argv, index, flag) {
+    const value = argv[index];
+    if (!value || value.startsWith("--")) {
+        throw new Error(`Expected a value after ${flag}`);
+    }
+    return value;
+}
+function getHelpText() {
+    return [
+        "Usage: ovsdb-generate [options]",
+        "",
+        "Inputs:",
+        "  --schema <file>         Read an OVSDB schema JSON file",
+        "  --socket <path>         Read schema from a live OVSDB Unix socket",
+        "  --host <name>           Read schema from a live OVSDB TCP/TLS endpoint",
+        "  --port <number>         Port for TCP/TLS introspection (default: 6640)",
+        "  --db <name>             Database name for live introspection",
+        "  --tls                   Enable TLS for live TCP connections",
+        "  --tls-insecure          Disable TLS certificate verification",
+        "  --tls-servername <sni>  Override TLS server name",
+        "  --tls-ca-file <file>    PEM CA bundle for TLS verification",
+        "  --tls-cert-file <file>  PEM client certificate for mTLS",
+        "  --tls-key-file <file>   PEM client private key for mTLS",
+        "",
+        "Output:",
+        "  --out <file>            Write generated TypeScript to a file",
+        "  --stdout                Print generated TypeScript to stdout",
+        "",
+        "Generation:",
+        "  --name <typeName>       Override generated top-level database type name",
+        "  --import-from <module>  Override imported OVSDB type module",
+        "",
+        "Other:",
+        "  -h, --help              Show this help text",
+        ""
+    ].join("\n");
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist-cli/generator.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesFromSchema = generateTypesFromSchema;
+exports.generateTypesFile = generateTypesFile;
+exports.readSchemaFile = readSchemaFile;
+exports.fetchSchemaFromOvsdb = fetchSchemaFromOvsdb;
+exports.createGeneratorClientOptions = createGeneratorClientOptions;
+const promises_1 = require("node:fs/promises");
+const index_1 = require("./index");
+const OVSDB_IMPORT_TYPES = ["OvsMap", "OvsSet", "Uuid"];
+/**
+ * Generates TypeScript types from an OVSDB schema.
+ *
+ * The output is designed for direct use as the generic database model for
+ * {@link OVSDBClient}.
+ */
+function generateTypesFromSchema(options) {
+    const { schema } = options;
+    const importFrom = options.importFrom ?? "@sourceregistry/node-ovsdb";
+    const databaseTypeName = options.databaseTypeName ?? `${toPascalCase(schema.name)}Database`;
+    const importLine = `import type {${OVSDB_IMPORT_TYPES.join(", ")}} from "${importFrom}";`;
+    const tableNames = Object.keys(schema.tables).sort((left, right) => left.localeCompare(right));
+    const rowInterfaces = tableNames.map((tableName) => {
+        const interfaceName = `${toPascalCase(tableName)}Row`;
+        const table = schema.tables[tableName];
+        const propertyLines = Object.keys(table.columns)
+            .sort((left, right) => left.localeCompare(right))
+            .map((columnName) => {
+            const column = table.columns[columnName];
+            const tsType = renderColumnType(column.type);
+            const optional = isOptionalColumn(column.type) ? "?" : "";
+            return `    ${toPropertyKey(columnName)}${optional}: ${tsType};`;
+        });
+        return [
+            `/**`,
+            ` * Row model for the \`${tableName}\` table in the \`${schema.name}\` schema.`,
+            ` */`,
+            `export interface ${interfaceName} {`,
+            ...propertyLines,
+            `}`
+        ].join("\n");
+    });
+    const databaseLines = [
+        `/**`,
+        ` * Generated database model for the \`${schema.name}\` schema.`,
+        ` */`,
+        `export interface ${databaseTypeName} {`,
+        ...tableNames.map((tableName) => `    ${toPropertyKey(tableName)}: ${toPascalCase(tableName)}Row;`),
+        `}`
+    ];
+    const tableNamesConst = [
+        `/**`,
+        ` * Table names available in the \`${schema.name}\` schema.`,
+        ` */`,
+        `export const ${databaseTypeName}TableNames = ${JSON.stringify(tableNames)} as const;`
+    ];
+    return [
+        `/* eslint-disable */`,
+        `/*`,
+        ` * This file was generated by ovsdb-generate.`,
+        ` * Schema: ${schema.name}@${schema.version}`,
+        ` */`,
+        "",
+        importLine,
+        "",
+        ...rowInterfaces.flatMap((block) => [block, ""]),
+        ...databaseLines,
+        "",
+        ...tableNamesConst
+    ].join("\n").trimEnd() + "\n";
+}
+/**
+ * Loads a schema from a file or a live OVSDB server and optionally writes the
+ * generated TypeScript output to disk.
+ */
+async function generateTypesFile(options) {
+    const schema = await loadSchema(options);
+    const output = generateTypesFromSchema({
+        schema,
+        databaseTypeName: options.databaseTypeName,
+        importFrom: options.importFrom
+    });
+    if (options.outputPath) {
+        await (0, promises_1.writeFile)(options.outputPath, output, "utf8");
+    }
+    return output;
+}
+/**
+ * Reads a schema JSON file from disk.
+ */
+async function readSchemaFile(schemaPath) {
+    const raw = await (0, promises_1.readFile)(schemaPath, "utf8");
+    return JSON.parse(raw);
+}
+/**
+ * Reads a schema from a live OVSDB server.
+ */
+async function fetchSchemaFromOvsdb(options) {
+    const client = new index_1.OVSDBClient(await createGeneratorClientOptions(options));
+    try {
+        await client.connect();
+        return await client.getSchema(options.databaseName ?? "Open_vSwitch");
+    }
+    finally {
+        await client.close();
+    }
+}
+async function loadSchema(options) {
+    if (options.schemaPath) {
+        return await readSchemaFile(options.schemaPath);
+    }
+    return await fetchSchemaFromOvsdb({
+        socketPath: options.socketPath,
+        host: options.host,
+        port: options.port,
+        tls: options.tls,
+        tlsInsecure: options.tlsInsecure,
+        tlsServername: options.tlsServername,
+        tlsCaFile: options.tlsCaFile,
+        tlsCertFile: options.tlsCertFile,
+        tlsKeyFile: options.tlsKeyFile,
+        databaseName: options.databaseName
+    });
+}
+/**
+ * Builds client transport options for live schema introspection.
+ */
+async function createGeneratorClientOptions(options) {
+    if (!options.host) {
+        return {
+            socketPath: options.socketPath
+        };
+    }
+    return {
+        host: options.host,
+        port: options.port,
+        tls: options.tls,
+        tlsOptions: {
+            servername: options.tlsServername ?? options.host,
+            rejectUnauthorized: options.tlsInsecure ? false : undefined,
+            ca: options.tlsCaFile ? await (0, promises_1.readFile)(options.tlsCaFile, "utf8") : undefined,
+            cert: options.tlsCertFile ? await (0, promises_1.readFile)(options.tlsCertFile, "utf8") : undefined,
+            key: options.tlsKeyFile ? await (0, promises_1.readFile)(options.tlsKeyFile, "utf8") : undefined
+        }
+    };
+}
+function renderColumnType(type) {
+    if (typeof type === "string") {
+        return renderAtomicType(type);
+    }
+    if ("value" in type && type.value !== undefined) {
+        return `OvsMap<${renderBaseType(type.key)}, ${renderBaseType(type.value)}>`;
+    }
+    if (isScalarType(type)) {
+        return renderBaseType(type.key);
+    }
+    return `OvsSet<${renderBaseType(type.key)}>`;
+}
+function isOptionalColumn(type) {
+    if (typeof type === "string") {
+        return false;
+    }
+    return type.min === 0;
+}
+function isScalarType(type) {
+    const min = type.min ?? 1;
+    const max = type.max ?? 1;
+    return min === 1 && max === 1;
+}
+function renderBaseType(baseType) {
+    if (typeof baseType === "string") {
+        return renderAtomicType(baseType);
+    }
+    if (baseType.enum) {
+        return renderEnum(baseType.enum);
+    }
+    return renderAtomicType(baseType.type);
+}
+function renderAtomicType(type) {
+    switch (type) {
+        case "integer":
+        case "real":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "string":
+            return "string";
+        case "uuid":
+            return "Uuid";
+        default:
+            return "unknown";
+    }
+}
+function renderEnum(value) {
+    if (Array.isArray(value) && value[0] === "set" && Array.isArray(value[1])) {
+        const members = value[1]
+            .map((member) => typeof member === "string" ? JSON.stringify(member) : renderJsonValue(member))
+            .join(" | ");
+        return members || "never";
+    }
+    return renderJsonValue(value);
+}
+function renderJsonValue(value) {
+    return JSON.stringify(value);
+}
+function toPascalCase(value) {
+    return value
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .split(" ")
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+function toPropertyKey(value) {
+    return /^[$A-Z_][0-9A-Z_$]*$/i.test(value) ? value : JSON.stringify(value);
+}