@uns-kit/core 0.0.1

package/dist/tools/auth/secure-store.js

@@ -0,0 +1,110 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+/**
+ * Try to lazily import keytar without making it a hard dependency.
+ */
+async function tryLoadKeytar() {
+    try {
+        // Avoid static import to prevent type resolution errors when not installed
+        const dynamicImport = new Function("m", "return import(m)");
+        const mod = await dynamicImport("keytar");
+        return (mod && (mod.default || mod)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+class KeytarStore {
+    service;
+    keytar;
+    constructor(service, keytar) {
+        this.service = service;
+        this.keytar = keytar;
+    }
+    async get(key) {
+        return (await this.keytar.getPassword(this.service, key)) ?? null;
+    }
+    async set(key, value) {
+        await this.keytar.setPassword(this.service, key, value);
+    }
+    async del(key) {
+        await this.keytar.deletePassword(this.service, key);
+    }
+}
+class FileStore {
+    filePath;
+    constructor(namespace) {
+        const baseDir = FileStore.resolveBaseDir();
+        const folder = path.join(baseDir, "uns-auth");
+        if (!fs.existsSync(folder)) {
+            fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+        }
+        this.filePath = path.join(folder, `${FileStore.sanitize(namespace)}.json`);
+        if (!fs.existsSync(this.filePath)) {
+            fs.writeFileSync(this.filePath, "{}", { mode: 0o600 });
+        }
+        try {
+            // tighten permissions if possible (no-op on Windows)
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch {
+            // ignore
+        }
+    }
+    static resolveBaseDir() {
+        if (process.platform === "win32") {
+            return process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+        }
+        // Linux and macOS default to XDG_CONFIG_HOME or ~/.config
+        return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    }
+    static sanitize(name) {
+        return name.replace(/[^a-zA-Z0-9_.-]/g, "_");
+    }
+    async load() {
+        try {
+            const raw = await fs.promises.readFile(this.filePath, "utf-8");
+            return JSON.parse(raw || "{}");
+        }
+        catch {
+            return {};
+        }
+    }
+    async save(data) {
+        const json = JSON.stringify(data, null, 2);
+        await fs.promises.writeFile(this.filePath, json, { mode: 0o600 });
+        try {
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch {
+            // ignore
+        }
+    }
+    async get(key) {
+        const data = await this.load();
+        return data[key] ?? null;
+    }
+    async set(key, value) {
+        const data = await this.load();
+        data[key] = value;
+        await this.save(data);
+    }
+    async del(key) {
+        const data = await this.load();
+        delete data[key];
+        await this.save(data);
+    }
+}
+export class SecureStoreFactory {
+    /**
+     * Creates a secure store for a namespace. Tries keytar first; falls back to file store.
+     */
+    static async create(namespace) {
+        const keytar = await tryLoadKeytar();
+        if (keytar) {
+            return new KeytarStore(namespace, keytar);
+        }
+        return new FileStore(namespace);
+    }
+}

package/dist/tools/base-path.d.ts

@@ -0,0 +1 @@
+export declare const basePath: string;

package/dist/tools/base-path.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+const fName = fileURLToPath(import.meta.url);
+const dName = dirname(fName);
+export const basePath = resolve(dName, "../..");

package/dist/tools/generate-config-schema.d.ts

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

package/dist/tools/generate-config-schema.js

@@ -0,0 +1,23 @@
+// scripts/generate-config-artifacts.ts
+import fs from "node:fs";
+import path from "node:path";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodToTs, printNode } from "zod-to-ts";
+// Import the plain ZodObject (no superRefine)
+import { baseSchema } from "../uns-config/config-schema.js";
+function write(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, data);
+}
+// 1) JSON Schema for VS Code $schema
+const jsonSchema = zodToJsonSchema(baseSchema, "AppConfig");
+write(path.resolve("config.schema.json"), JSON.stringify(jsonSchema, null, 2));
+// 2) TypeScript `export type AppConfig = {...}`
+const { node } = zodToTs(baseSchema, "AppConfig");
+const tsContent = "/* Auto-generated. Do not edit by hand. */\n" +
+    "export type AppConfig = " +
+    printNode(node) +
+    "\n";
+// Put it wherever you want. You earlier asked for root (beside config-file.ts):
+write(path.resolve("./src/app-config.ts"), tsContent);
+console.log("Generated config.schema.json and app-config.ts");

package/dist/tools/initialize.d.ts

@@ -0,0 +1 @@
+export declare const packageJsonPath: string;

package/dist/tools/initialize.js

@@ -0,0 +1,103 @@
+import * as azdev from "azure-devops-node-api";
+import chalk from "chalk";
+import { readFile } from "fs/promises";
+import readline from "node:readline";
+import * as path from "path";
+import { CleanOptions, simpleGit } from "simple-git";
+import fs from "fs-extra";
+import { basePath } from "./base-path.js";
+const git = simpleGit("./").clean(CleanOptions.FORCE);
+export const packageJsonPath = path.join(basePath, "package.json");
+const orgUrl = "https://sijit@dev.azure.com/sijit";
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+let token = "";
+const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+const repoName = packageJson.name;
+async function run() {
+    let repos;
+    let gitApi;
+    const project = "industry40";
+    try {
+        const authHandler = azdev.getPersonalAccessTokenHandler(token);
+        const connection = new azdev.WebApi(orgUrl, authHandler);
+        gitApi = await connection.getGitApi();
+        repos = await gitApi.getRepositories(project);
+    }
+    catch (error) {
+        console.error("Your AZURE_PAT environment variable has probably expired.");
+        console.log("Please update your AZURE_PAT environment with a new one on.");
+        console.log("You can create a new one at[https://dev.azure.com/sijit/_usersSettings/tokens]");
+    }
+    if (repos.filter((x) => x.name == repoName).length > 0) {
+        console.log(chalk.red.bold(`Error: Repository ${repoName} in project ${project} already exists.`));
+    }
+    else {
+        process.stdout.write(`Create ${repoName} in project ${project}`);
+        try {
+            await gitApi.createRepository({ name: repoName }, project);
+            console.log(chalk.green.bold(` ... OK`));
+        }
+        catch (error) {
+            console.error(chalk.red.bold(`\n${error}`));
+        }
+        process.stdout.write(`Initialize local git repository on branch master`);
+        try {
+            await git.init();
+            await git.checkoutLocalBranch("master");
+            await git.add(".");
+            await git.commit("Initial commit");
+            console.log(chalk.green.bold(` ... OK`));
+        }
+        catch (error) {
+            console.error(chalk.red.bold(`\n${error}`));
+        }
+        process.stdout.write(`Add remote origin.`);
+        try {
+            await git.remote([
+                "add",
+                "origin",
+                `git@ssh.dev.azure.com:v3/sijit/industry40/${repoName}`,
+            ]);
+            console.log(chalk.green.bold(` ... OK`));
+        }
+        catch (error) {
+            console.error(chalk.red.bold(`\n${error}`));
+        }
+        process.stdout.write(`Push master to remote`);
+        try {
+            await git.push("origin", "master");
+            console.log(chalk.green.bold(` ... OK`));
+        }
+        catch (error) {
+            console.error(chalk.red.bold(`\n${error}`));
+        }
+        process.stdout.write(`Create default config.json from config-template.json`);
+        try {
+            fs.copyFileSync(path.join(basePath, 'config-template.json'), path.join(basePath, 'config.json'));
+            console.log(chalk.green.bold(` ... OK`));
+        }
+        catch (error) {
+            console.error(chalk.red.bold(`\n${error}`));
+        }
+        console.log(chalk.green.bold(`\nNow you can add pipeline for ${repoName} in Azure DevOps pipelines for the project ${project}.`));
+    }
+}
+console.log(chalk.green.bold(`Create new RTT: ${repoName}\n`));
+const envPat = process.env.AZURE_PAT;
+if (envPat && envPat.length > 10) {
+    rl.close();
+    console.log("Using PAT from your AZURE_PAT environment");
+    token = envPat;
+    run();
+}
+else {
+    console.log("Could not find AZURE_PAT environment.");
+    rl.question(`Please enter your PAT, you can create one at [https://dev.azure.com/sijit/_usersSettings/tokens]: `, (newToken) => {
+        rl.close();
+        token = newToken;
+        run();
+    });
+}

package/dist/tools/make.d.ts

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

package/dist/tools/make.js

@@ -0,0 +1,27 @@
+import fs from "fs-extra";
+import { basePath } from "./base-path.js";
+import * as path from "path";
+import { execSync } from 'child_process';
+const binDir = path.join(basePath, 'bin/');
+try {
+    const ua = process.env.npm_config_user_agent || "";
+    const pm = ua.startsWith("pnpm") ? "pnpm" : ua.startsWith("yarn") ? "yarn" : "npm";
+    execSync(`${pm} run build`, { stdio: 'inherit' });
+    fs.rmSync(binDir, {
+        recursive: true,
+        force: true,
+    });
+    fs.mkdirSync(binDir, { recursive: true });
+    fs.copyFileSync(path.join(basePath, 'LICENSE'), path.join(binDir, 'LICENSE'));
+    fs.copyFileSync(path.join(basePath, 'package.json'), path.join(binDir, 'package.json'));
+    fs.copySync(path.join(basePath, 'dist'), path.join(binDir, 'dist/'));
+    // After all files are copied, check for ../local-tools/make.js and run it if exists
+    const localToolsDir = path.resolve(basePath, 'dist/local-tools');
+    const makeJsPath = path.join(localToolsDir, 'make.js');
+    if (fs.existsSync(makeJsPath)) {
+        execSync(`node "${makeJsPath}"`, { stdio: 'inherit' });
+    }
+}
+catch (error) {
+    console.log(`error: ${error}`);
+}

package/dist/tools/pull-request.d.ts

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

package/dist/tools/pull-request.js

@@ -0,0 +1,157 @@
+import * as azdev from "azure-devops-node-api";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import fs from "fs";
+import { readFile } from "fs/promises";
+import readline from "node:readline";
+import * as path from "path";
+import * as prettier from "prettier";
+import { CleanOptions, simpleGit } from "simple-git";
+import util from "util";
+import { basePath } from "../base-path.js";
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+const question = util.promisify(rl.question).bind(rl);
+const git = simpleGit("./").clean(CleanOptions.FORCE);
+const packageJsonPath = path.join(basePath, "package.json");
+const unsLibraryPath = path.join(basePath, "uns-library.json");
+const orgUrl = "https://sijit@dev.azure.com/sijit";
+const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+const repoName = packageJson.name;
+const version = packageJson.version;
+const branches = await git.branchLocal();
+const currentBranch = branches.current;
+const gitStatus = await git.status();
+let token = "";
+try {
+    await main();
+    rl.close();
+}
+catch (error) {
+    console.log(chalk.red.bold(`\n${error}`));
+    rl.close();
+}
+async function main() {
+    if (!gitStatus.isClean()) {
+        throw new Error(`Repository needs to be clean. Please commit or stash the changes.`);
+    }
+    else if (currentBranch == "master") {
+        throw new Error(`You can not create pull request from master to master.`);
+    }
+    else {
+        const envPat = process.env.AZURE_PAT;
+        while (!token) {
+            if (envPat && envPat.length > 10) {
+                token = envPat;
+                const authHandler = azdev.getPersonalAccessTokenHandler(token);
+                const connection = new azdev.WebApi(orgUrl, authHandler);
+                try {
+                    console.log("Using PAT from your AZURE_PAT environment");
+                    await connection.connect();
+                }
+                catch (error) {
+                    console.log("The provided PAT is invalid or expired. Please provide a valid PAT.");
+                    token = "";
+                }
+            }
+            if (!token) {
+                token = await question(`Please enter your PAT, you can create one at [https://dev.azure.com/sijit/_usersSettings/tokens]: `);
+                const authHandler = azdev.getPersonalAccessTokenHandler(token);
+                const connection = new azdev.WebApi(orgUrl, authHandler);
+                try {
+                    await connection.connect();
+                }
+                catch (error) {
+                    console.log("The provided PAT is invalid or expired. Please provide a valid PAT.");
+                    token = "";
+                }
+            }
+        }
+        const version = await getVersion();
+        await setVersion(version);
+        await runMake();
+        await commitChanges(version);
+        await pushChanges();
+        await createPullRequest(version);
+    }
+}
+async function getVersion() {
+    let versionExists = true;
+    let newVersion = version;
+    while (versionExists) {
+        newVersion = await question(`Every PR needs a unique version, please accept current version or enter a new one [${version}]: `) || version;
+        const remoteTags = await git.listRemote(["--tags"]);
+        if (remoteTags.indexOf(`refs/tags/${newVersion}`) > 0) {
+            console.log(chalk.bold.red(`Version ${newVersion} already exists on the server`));
+        }
+        else {
+            console.log(`Using version ${newVersion}`);
+            versionExists = false;
+        }
+    }
+    return newVersion;
+}
+async function runMake() {
+    execSync("npm run make");
+}
+async function commitChanges(newVersion) {
+    process.stdout.write(`Commit changes to branch ${currentBranch} `);
+    await git.add(".");
+    await git.commit(`Set new production version: ${newVersion}`);
+    console.log(chalk.green.bold(` ... OK`));
+}
+async function pushChanges() {
+    process.stdout.write(`Push changes to remote branch ${currentBranch} `);
+    await git.push("origin", currentBranch);
+    console.log(chalk.green.bold(` ... OK`));
+}
+async function setVersion(newVersion) {
+    packageJson.version = newVersion;
+    const docString = await prettier.format(JSON.stringify(packageJson), {
+        parser: "json",
+    });
+    fs.writeFileSync("package.json", docString, "utf8");
+    if (repoName === "template-uns-rtt") {
+        try {
+            const unsLibraryFile = await readFile(unsLibraryPath, "utf8");
+            const unsLibrary = JSON.parse(unsLibraryFile);
+            unsLibrary.version = newVersion;
+            const unsLibraryDoc = await prettier.format(JSON.stringify(unsLibrary), {
+                parser: "json",
+            });
+            fs.writeFileSync(unsLibraryPath, unsLibraryDoc, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                const unsLibraryDoc = await prettier.format(JSON.stringify({ name: repoName, version: newVersion }), { parser: "json" });
+                fs.writeFileSync(unsLibraryPath, unsLibraryDoc, "utf8");
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+async function createPullRequest(tag) {
+    const title = await question(`Title for the pull request: `);
+    const description = await question(`Description for the pull request: `);
+    process.stdout.write(`Create new pull request from ${currentBranch} to master `);
+    const authHandler = azdev.getPersonalAccessTokenHandler(token);
+    const connection = new azdev.WebApi(orgUrl, authHandler);
+    const gitApi = await connection.getGitApi();
+    const project = "industry40";
+    const repos = await gitApi.getRepositories(project);
+    const repoId = repos.filter((x) => x.name == repoName)[0].id;
+    const gitPullRequestToCreate = {
+        sourceRefName: `refs/heads/${currentBranch}`,
+        targetRefName: "refs/heads/master",
+        title,
+        description,
+        labels: [{ active: true, name: tag }]
+    };
+    gitApi.createPullRequest(gitPullRequestToCreate, repoId, project);
+    console.log(chalk.green.bold(` ... OK`));
+    console.log(`Pull request created at ` + chalk.green.bold(`[https://dev.azure.com/sijit/${project}/_git/${repoName}/pullrequests]`));
+}

package/dist/tools/refresh-uns.d.ts

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

package/dist/tools/refresh-uns.js

@@ -0,0 +1,109 @@
+import { GraphQLClient, gql, ClientError } from "graphql-request";
+import { basePath } from "./base-path.js";
+import * as path from "path";
+import * as fs from 'fs';
+import { ConfigFile } from "../config-file.js";
+import { AuthClient } from "./auth/index.js";
+const config = await ConfigFile.loadConfig();
+// Helper function to write content to a file
+async function writeToFile(filePath, content) {
+    return new Promise((resolve, reject) => {
+        fs.writeFile(filePath, content, (error) => {
+            if (error) {
+                console.error('Error writing file:', error);
+                return reject(error);
+            }
+            console.log(`${path.basename(filePath)} updated.`);
+            resolve();
+        });
+    });
+}
+// Function to process tree structure recursively
+function generateUnsTopics(tree, currentPath) {
+    return tree
+        .map(element => {
+        const newPath = `${currentPath}${element.unsNode}/`;
+        const childrenTopics = element.children?.length
+            ? generateUnsTopics(element.children, newPath)
+            : '';
+        return `"${newPath}" |${childrenTopics}`;
+    })
+        .join('');
+}
+// Prepare GraphQL client with Authorization from auth library
+const auth = await AuthClient.create();
+let accessToken = await auth.getAccessToken();
+let client = new GraphQLClient(config.uns.graphql, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+});
+async function requestWithAuth(document) {
+    try {
+        return await client.request(document);
+    }
+    catch (err) {
+        const isAuthErr = err instanceof ClientError && (err.response.status === 401 || err.response.status === 403);
+        if (isAuthErr) {
+            // Attempt to get a fresh token (will try refresh, then prompt)
+            accessToken = await auth.getAccessToken();
+            client.setHeader('Authorization', `Bearer ${accessToken}`);
+            return await client.request(document);
+        }
+        throw err;
+    }
+}
+// Fetch and generate UnsTopics
+async function refreshUnsTopics() {
+    const document = gql `
+  query GetTreeStructure {
+    GetTreeStructure {
+      id
+      parent
+      unsNode
+      children {
+        id
+        parent
+        unsNode
+        children {
+          id
+          parent
+          unsNode
+          children {
+            id
+            parent
+            unsNode
+            children {
+              id
+              parent
+              unsNode
+              children {
+                id
+                parent
+                unsNode
+              }
+            }
+          }
+        }
+      }
+    }
+  }`;
+    const query = await requestWithAuth(document);
+    const tree = query.GetTreeStructure;
+    const vsebina = `export type UnsTopics = ${generateUnsTopics(tree, '')}\n(string & {});`;
+    await writeToFile(path.join(basePath, "src/uns/uns-topics.ts"), vsebina);
+}
+// Fetch and generate UnsTags
+async function refreshUnsTags() {
+    const document = gql `
+  query Query {
+    GetTags
+  }`;
+    const query = await requestWithAuth(document);
+    const tags = query.GetTags;
+    const vsebina = `export type UnsTags = ${tags.map(tag => `"${tag}" |`).join('')}\n(string & {});`;
+    await writeToFile(path.join(basePath, "src/uns/uns-tags.ts"), vsebina);
+}
+// Execute the refresh processes
+async function refresh() {
+    await Promise.all([refreshUnsTopics(), refreshUnsTags()]);
+}
+refresh().catch(error => console.error('Error during refresh:', error));