@contrail/flexplm 1.7.3 → 1.7.4-alpha.7bbda17

package/lib/cli/commands/config-create.d.ts

@@ -0,0 +1,5 @@
+export declare class ConfigCreateCommand {
+    private prompt;
+    private findTemplate;
+    run(): Promise<void>;
+}

package/lib/cli/commands/config-create.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCreateCommand = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const TEMPLATE_FILENAME = 'config-template.json.template';
+const ORG_PLACEHOLDER = '<ORG_NAME>';
+const APP_IDENTIFIER_PLACEHOLDER = '<APP_IDENTIFIER>';
+const DEFAULT_APP_IDENTIFIER = '@vibeiq/flexplm-connector';
+class ConfigCreateCommand {
+    prompt(rl, question) {
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer));
+        });
+    }
+    findTemplate() {
+        const candidates = [
+            path.join(__dirname, '..', 'template', TEMPLATE_FILENAME),
+            path.join(__dirname, '..', '..', '..', 'src', 'cli', 'template', TEMPLATE_FILENAME),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error(`Could not locate ${TEMPLATE_FILENAME}. Tried:\n  ${candidates.join('\n  ')}`);
+    }
+    async run() {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const onSigint = () => {
+            rl.close();
+            process.stdout.write('\n');
+            process.exit(130);
+        };
+        process.once('SIGINT', onSigint);
+        let orgName;
+        let appIdentifier;
+        try {
+            orgName = (await this.prompt(rl, 'orgName: ')).trim();
+            appIdentifier = (await this.prompt(rl, `appIdentifier (default: ${DEFAULT_APP_IDENTIFIER}): `)).trim() || DEFAULT_APP_IDENTIFIER;
+        }
+        finally {
+            process.removeListener('SIGINT', onSigint);
+            rl.close();
+        }
+        if (!orgName) {
+            throw new Error('orgName is required');
+        }
+        const templatePath = this.findTemplate();
+        const templateBody = fs.readFileSync(templatePath, 'utf8');
+        const rendered = templateBody.split(ORG_PLACEHOLDER).join(orgName).split(APP_IDENTIFIER_PLACEHOLDER).join(appIdentifier);
+        const outPath = path.resolve(process.cwd(), `${orgName}-flexplmConfig.json`);
+        if (fs.existsSync(outPath)) {
+            throw new Error(`Refusing to overwrite existing file: ${outPath}`);
+        }
+        fs.writeFileSync(outPath, rendered, 'utf8');
+        console.log(`Created ${outPath}`);
+        console.log('Only "orgName" and "appIdentifier" are required. See the "_availableAttributes" block in the file for other attributes this org can set (apiHost, identifierAtts, LCSMaterial, etc.) — add the ones you need as real top-level keys, then delete "_availableAttributes"; the connector ignores it and applies defaults at runtime for anything you omit.');
+    }
+}
+exports.ConfigCreateCommand = ConfigCreateCommand;

package/lib/cli/commands/config-create.spec.d.ts

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

package/lib/cli/commands/config-create.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+let answers = [];
+jest.mock('readline', () => ({
+    createInterface: () => ({
+        question: (_q, cb) => cb(answers.shift() || ''),
+        close: () => { },
+    }),
+}));
+const config_create_1 = require("./config-create");
+describe('ConfigCreateCommand', () => {
+    let tempDir;
+    let originalCwd;
+    let logSpy;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flexplm-config-create-'));
+        process.chdir(tempDir);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        answers = [];
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('writes <orgName>-flexplmConfig.json with orgName and appIdentifier filled in', async () => {
+        answers = ['acme', '@vibeiq/flexplm-connector'];
+        await new config_create_1.ConfigCreateCommand().run();
+        const outPath = path.join(tempDir, 'acme-flexplmConfig.json');
+        expect(fs.existsSync(outPath)).toBe(true);
+        const config = JSON.parse(fs.readFileSync(outPath, 'utf8'));
+        expect(config.orgName).toEqual('acme');
+        expect(config.appIdentifier).toEqual('@vibeiq/flexplm-connector');
+    });
+    it('defaults appIdentifier to @vibeiq/flexplm-connector when left blank', async () => {
+        answers = ['acme', ''];
+        await new config_create_1.ConfigCreateCommand().run();
+        const outPath = path.join(tempDir, 'acme-flexplmConfig.json');
+        const config = JSON.parse(fs.readFileSync(outPath, 'utf8'));
+        expect(config.appIdentifier).toEqual('@vibeiq/flexplm-connector');
+    });
+    it('throws when orgName is empty', async () => {
+        answers = ['   '];
+        await expect(new config_create_1.ConfigCreateCommand().run()).rejects.toThrow(/orgName is required/);
+    });
+    it('refuses to overwrite an existing file', async () => {
+        const existing = path.join(tempDir, 'acme-flexplmConfig.json');
+        fs.writeFileSync(existing, 'do not clobber', 'utf8');
+        answers = ['acme', '@vibeiq/flexplm-connector'];
+        await expect(new config_create_1.ConfigCreateCommand().run()).rejects.toThrow(/Refusing to overwrite/);
+        expect(fs.readFileSync(existing, 'utf8')).toEqual('do not clobber');
+    });
+});

package/lib/cli/commands/config-upload.d.ts

@@ -0,0 +1,19 @@
+interface ConfigUploadOptions {
+    filePath: string;
+    message?: string;
+    branch?: string;
+    skipGit: boolean;
+    updateConfig: boolean;
+}
+export declare class ConfigUploadCommand {
+    static parseArgs(args: string[]): ConfigUploadOptions;
+    static buildCommitMessage(userMessage: string, fileId: string): string;
+    private prompt;
+    private promptHidden;
+    private runGit;
+    private tryRunGit;
+    private commitToGit;
+    run(args: string[]): Promise<void>;
+    private setConfigFileOnAppOrg;
+}
+export {};

package/lib/cli/commands/config-upload.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigUploadCommand = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const sdk_1 = require("@contrail/sdk");
+class ConfigUploadCommand {
+    static parseArgs(args) {
+        let filePath;
+        let message;
+        let branch;
+        let skipGit = false;
+        let updateConfig = false;
+        for (let i = 0; i < args.length; i++) {
+            const a = args[i];
+            if (a === '-m') {
+                message = args[++i];
+                if (message === undefined) {
+                    throw new Error('-m requires a commit message argument');
+                }
+            }
+            else if (a === '-b') {
+                branch = args[++i];
+                if (branch === undefined) {
+                    throw new Error('-b requires a branch name argument');
+                }
+            }
+            else if (a === '--skip-git' || a === '--skipGit') {
+                skipGit = true;
+            }
+            else if (a === '--update-config') {
+                updateConfig = true;
+            }
+            else if (a.startsWith('-')) {
+                throw new Error(`Unknown option: ${a}`);
+            }
+            else if (!filePath) {
+                filePath = a;
+            }
+            else {
+                throw new Error(`Unexpected argument: ${a}`);
+            }
+        }
+        if (!filePath) {
+            throw new Error('upload: missing <path.json> argument');
+        }
+        return { filePath, message, branch, skipGit, updateConfig };
+    }
+    static buildCommitMessage(userMessage, fileId) {
+        const lines = userMessage.split(/\r?\n/);
+        lines[0] = `${lines[0]} [fileId: ${fileId}]`;
+        return lines.join('\n');
+    }
+    prompt(question) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    promptHidden(question) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+            const rlAny = rl;
+            rlAny._writeToOutput = (str) => {
+                if (str.includes(question)) {
+                    rlAny.output.write(str);
+                }
+            };
+            rl.question(question, (answer) => {
+                rl.close();
+                process.stdout.write('\n');
+                resolve(answer);
+            });
+        });
+    }
+    runGit(args, cwd) {
+        return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    tryRunGit(args, cwd) {
+        try {
+            const stdout = this.runGit(args, cwd);
+            return { ok: true, stdout, stderr: '' };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                stdout: err && err.stdout ? err.stdout.toString() : '',
+                stderr: err && err.stderr ? err.stderr.toString() : (err && err.message) || '',
+            };
+        }
+    }
+    async commitToGit(absPath, fileId, options) {
+        const repoDir = path.dirname(absPath);
+        const relPath = path.basename(absPath);
+        const versionCheck = this.tryRunGit(['--version'], repoDir);
+        if (!versionCheck.ok) {
+            console.log('git command not available; skipping git commit.');
+            return;
+        }
+        const insideRepo = this.tryRunGit(['rev-parse', '--is-inside-work-tree'], repoDir);
+        if (!insideRepo.ok || insideRepo.stdout.trim() !== 'true') {
+            console.log(`Not inside a git working tree (${repoDir}); skipping git commit.`);
+            return;
+        }
+        const tracked = this.tryRunGit(['ls-files', '--error-unmatch', relPath], repoDir);
+        if (!tracked.ok) {
+            const answer = (await this.prompt(`File is not tracked by git: ${relPath}\nAdd it to git? (Y/n): `)).toLowerCase();
+            if (answer === 'n' || answer === 'no') {
+                console.log('Nothing was done in git.');
+                return;
+            }
+        }
+        if (options.branch) {
+            const branchResult = this.tryRunGit(['checkout', '-b', options.branch], repoDir);
+            if (!branchResult.ok) {
+                throw new Error(`Failed to create branch "${options.branch}": ${branchResult.stderr.trim()}`);
+            }
+            console.log(`Created and switched to branch "${options.branch}"`);
+        }
+        let message = options.message;
+        if (!message) {
+            message = await this.prompt('Commit message: ');
+            if (!message) {
+                throw new Error('A commit message is required');
+            }
+        }
+        const finalMessage = ConfigUploadCommand.buildCommitMessage(message, fileId);
+        const addResult = this.tryRunGit(['add', '--', relPath], repoDir);
+        if (!addResult.ok) {
+            throw new Error(`git add failed: ${addResult.stderr.trim()}`);
+        }
+        const commitResult = this.tryRunGit(['commit', '-m', finalMessage, '--', relPath], repoDir);
+        if (!commitResult.ok) {
+            throw new Error(`git commit failed: ${commitResult.stderr.trim() || commitResult.stdout.trim()}`);
+        }
+        console.log(commitResult.stdout.trim());
+    }
+    async run(args) {
+        const options = ConfigUploadCommand.parseArgs(args);
+        const absPath = path.resolve(process.cwd(), options.filePath);
+        if (!fs.existsSync(absPath)) {
+            throw new Error(`File not found: ${absPath}`);
+        }
+        if (!absPath.endsWith('.json')) {
+            throw new Error(`Expected a .json file, got: ${absPath}`);
+        }
+        const raw = fs.readFileSync(absPath, 'utf8');
+        let config;
+        try {
+            config = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`File is not valid JSON: ${absPath}\n${err && err.message ? err.message : err}`);
+        }
+        const orgName = config && config.orgName;
+        const appIdentifier = config && config.appIdentifier;
+        if (!orgName) {
+            throw new Error(`Config file is missing "orgName": ${absPath}`);
+        }
+        if (!appIdentifier) {
+            throw new Error(`Config file is missing "appIdentifier": ${absPath}`);
+        }
+        let email = process.env.CONTRAIL_CLI_EMAIL;
+        let password = process.env.CONTRAIL_CLI_PASSWORD;
+        if (!email) {
+            email = await this.prompt('Email: ');
+        }
+        if (!password) {
+            password = await this.promptHidden('Password: ');
+        }
+        if (!email || !password) {
+            throw new Error('Email and password are required');
+        }
+        await (0, sdk_1.login)({ orgSlug: orgName, email, password });
+        console.log(`Logged in to org "${orgName}" as ${email}`);
+        const apps = await new sdk_1.Entities().get({
+            entityName: 'app',
+            criteria: { identifier: appIdentifier },
+        });
+        if (!apps || apps.length !== 1) {
+            throw new Error(`Expected exactly one app with identifier "${appIdentifier}" in org "${orgName}", found ${apps ? apps.length : 0}`);
+        }
+        const app = apps[0];
+        const buffer = fs.readFileSync(absPath);
+        const fileName = path.basename(absPath);
+        const fileOwner = `app:${app.id}`;
+        const uploadedFile = await new sdk_1.Files().createAndUploadFileFromBuffer(buffer, 'application/json', fileName, fileOwner);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const responsePath = `${absPath}.uploaded-${timestamp}.json`;
+        fs.writeFileSync(responsePath, JSON.stringify(uploadedFile, null, 2), 'utf8');
+        console.log(`Wrote response to ${responsePath}`);
+        console.log(`FILE ID: ${uploadedFile.id}`);
+        if (!options.skipGit) {
+            await this.commitToGit(absPath, uploadedFile.id, options);
+        }
+        if (options.updateConfig) {
+            await this.setConfigFileOnAppOrg(app.id, appIdentifier, orgName, uploadedFile.id);
+        }
+    }
+    async setConfigFileOnAppOrg(appId, appIdentifier, orgName, fileId) {
+        const appOrgs = await new sdk_1.Entities().get({
+            entityName: 'app-org',
+            criteria: { appId },
+        });
+        if (!appOrgs || appOrgs.length === 0) {
+            throw new Error(`Failed to set the file onto the app config for "${appIdentifier}" because it is not installed in org "${orgName}". Install it via the admin console before using --update-config. You can paste the uploaded file's ID into the app config without needing to re-run this command.`);
+        }
+        if (appOrgs.length > 1) {
+            throw new Error(`Failed to set the file onto the app config for "${appIdentifier}" in org "${orgName}" because ${appOrgs.length} installations were identified. Expected one. Please contact customer support for assistance.`);
+        }
+        const appOrg = appOrgs[0];
+        const nextAppConfig = { ...(appOrg.appConfig || {}), configFile: fileId };
+        await new sdk_1.Entities().update({
+            entityName: 'app-org',
+            id: appOrg.id,
+            object: { appConfig: nextAppConfig },
+        });
+        console.log(`Successfully set "appConfig.configFile" for installed "${appIdentifier}" to new FILE ID: "${fileId}" on org "${orgName}"`);
+    }
+}
+exports.ConfigUploadCommand = ConfigUploadCommand;

package/lib/cli/commands/config-upload.spec.d.ts

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

package/lib/cli/commands/config-upload.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@contrail/sdk', () => ({
+    Entities: jest.fn(),
+    Files: jest.fn(),
+    login: jest.fn(),
+}));
+const config_upload_1 = require("./config-upload");
+describe('ConfigUploadCommand.parseArgs', () => {
+    it('parses a bare file path', () => {
+        const opts = config_upload_1.ConfigUploadCommand.parseArgs(['config.json']);
+        expect(opts).toEqual({
+            filePath: 'config.json',
+            message: undefined,
+            branch: undefined,
+            skipGit: false,
+            updateConfig: false,
+        });
+    });
+    it('parses -m commit message option', () => {
+        const opts = config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '-m', 'my message']);
+        expect(opts.message).toEqual('my message');
+        expect(opts.skipGit).toBe(false);
+    });
+    it('parses -b branch option', () => {
+        const opts = config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '-b', 'feature/x']);
+        expect(opts.branch).toEqual('feature/x');
+    });
+    it('parses --skip-git flag', () => {
+        const opts = config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '--skip-git']);
+        expect(opts.skipGit).toBe(true);
+    });
+    it('parses --update-config flag', () => {
+        const opts = config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '--update-config']);
+        expect(opts.updateConfig).toBe(true);
+    });
+    it('throws when -m is missing its value', () => {
+        expect(() => config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '-m'])).toThrow(/-m requires a commit message/);
+    });
+    it('throws on unknown option', () => {
+        expect(() => config_upload_1.ConfigUploadCommand.parseArgs(['config.json', '--bogus'])).toThrow(/Unknown option: --bogus/);
+    });
+    it('throws when no file path is provided', () => {
+        expect(() => config_upload_1.ConfigUploadCommand.parseArgs([])).toThrow(/missing <path\.json>/);
+    });
+});
+describe('ConfigUploadCommand.buildCommitMessage', () => {
+    it('appends fileId to the first line of a single-line message', () => {
+        expect(config_upload_1.ConfigUploadCommand.buildCommitMessage('initial commit', 'abc123')).toEqual('initial commit [fileId: abc123]');
+    });
+    it('handles CRLF line endings', () => {
+        const result = config_upload_1.ConfigUploadCommand.buildCommitMessage('header\r\nbody', 'fid');
+        expect(result).toEqual('header [fileId: fid]\nbody');
+    });
+});
+describe('ConfigUploadCommand.run', () => {
+    const fs = require('fs');
+    const os = require('os');
+    const path = require('path');
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flexplm-config-upload-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('throws when the config file is missing orgName', async () => {
+        const filePath = path.join(tempDir, 'bad.json');
+        fs.writeFileSync(filePath, JSON.stringify({ appIdentifier: '@vibeiq/flexplm-connector' }), 'utf8');
+        await expect(new config_upload_1.ConfigUploadCommand().run([filePath, '--skip-git'])).rejects.toThrow(/missing "orgName"/);
+    });
+    it('throws when the config file is missing appIdentifier', async () => {
+        const filePath = path.join(tempDir, 'bad.json');
+        fs.writeFileSync(filePath, JSON.stringify({ orgName: 'acme' }), 'utf8');
+        await expect(new config_upload_1.ConfigUploadCommand().run([filePath, '--skip-git'])).rejects.toThrow(/missing "appIdentifier"/);
+    });
+    it('throws when the file is not valid JSON', async () => {
+        const filePath = path.join(tempDir, 'bad.json');
+        fs.writeFileSync(filePath, '{not json', 'utf8');
+        await expect(new config_upload_1.ConfigUploadCommand().run([filePath, '--skip-git'])).rejects.toThrow(/not valid JSON/);
+    });
+    it('throws when the file does not exist', async () => {
+        await expect(new config_upload_1.ConfigUploadCommand().run([path.join(tempDir, 'nope.json'), '--skip-git'])).rejects.toThrow(/File not found/);
+    });
+    it('throws when the file is not a .json file', async () => {
+        const filePath = path.join(tempDir, 'config.txt');
+        fs.writeFileSync(filePath, '{}', 'utf8');
+        await expect(new config_upload_1.ConfigUploadCommand().run([filePath, '--skip-git'])).rejects.toThrow(/Expected a \.json file/);
+    });
+});

package/lib/cli/config-index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export declare class ConfigCli {
+    main(): Promise<void>;
+}
+export declare function main(): Promise<void>;

package/lib/cli/config-index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.ConfigCli = void 0;
+const config_create_1 = require("./commands/config-create");
+const config_upload_1 = require("./commands/config-upload");
+const USAGE = `Usage: flexplm-config <command> [args]
+
+Commands:
+  create                  Scaffold a new connector config .json file in the current directory
+  upload  <path.json> [opts] Upload a connector config .json file to VibeIQ
+
+Upload options:
+  -m <message>            Git commit message (prompted if omitted)
+  -b <branch>             Create a new git branch before committing
+  --skip-git              Skip the post-upload git commit (default: commit)
+  --update-config         Patch the app-org appConfig.configFile with the uploaded file ID without needing to paste into the admin console
+
+Environment (upload):
+  CONTRAIL_CLI_EMAIL      VibeIQ user email
+  CONTRAIL_CLI_PASSWORD   VibeIQ user password
+`;
+class ConfigCli {
+    async main() {
+        const [, , command, ...rest] = process.argv;
+        switch (command) {
+            case 'create':
+                await new config_create_1.ConfigCreateCommand().run();
+                return;
+            case 'upload':
+                if (!rest[0]) {
+                    console.error('upload: missing <path.json> argument');
+                    console.error(USAGE);
+                    process.exit(1);
+                }
+                await new config_upload_1.ConfigUploadCommand().run(rest);
+                return;
+            case undefined:
+            case '-h':
+            case '--help':
+            case 'help':
+                console.log(USAGE);
+                return;
+            default:
+                console.error(`Unknown command: ${command}`);
+                console.error(USAGE);
+                process.exit(1);
+        }
+    }
+}
+exports.ConfigCli = ConfigCli;
+function main() {
+    return new ConfigCli().main();
+}
+exports.main = main;
+if (require.main === module) {
+    main().catch((err) => {
+        console.error(err && err.message ? err.message : err);
+        process.exit(1);
+    });
+}

package/lib/cli/config-index.spec.d.ts

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

package/lib/cli/config-index.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createRunMock = jest.fn().mockResolvedValue(undefined);
+const uploadRunMock = jest.fn().mockResolvedValue(undefined);
+jest.mock('./commands/config-create', () => ({
+    ConfigCreateCommand: jest.fn().mockImplementation(() => ({ run: createRunMock })),
+}));
+jest.mock('./commands/config-upload', () => ({
+    ConfigUploadCommand: jest.fn().mockImplementation(() => ({ run: uploadRunMock })),
+}));
+const config_index_1 = require("./config-index");
+describe('config cli main dispatcher', () => {
+    let originalArgv;
+    let logSpy;
+    let errorSpy;
+    let exitSpy;
+    beforeEach(() => {
+        originalArgv = process.argv;
+        createRunMock.mockClear();
+        uploadRunMock.mockClear();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`__EXIT__:${code}`);
+        }));
+    });
+    afterEach(() => {
+        process.argv = originalArgv;
+        logSpy.mockRestore();
+        errorSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    function setArgv(...args) {
+        process.argv = ['node', 'cli', ...args];
+    }
+    it('dispatches the create command', async () => {
+        setArgv('create');
+        await (0, config_index_1.main)();
+        expect(createRunMock).toHaveBeenCalledTimes(1);
+        expect(uploadRunMock).not.toHaveBeenCalled();
+    });
+    it('dispatches the upload command and forwards remaining args', async () => {
+        setArgv('upload', 'config.json', '-m', 'msg', '--skip-git');
+        await (0, config_index_1.main)();
+        expect(uploadRunMock).toHaveBeenCalledWith(['config.json', '-m', 'msg', '--skip-git']);
+    });
+    it('exits when upload is missing its argument', async () => {
+        setArgv('upload');
+        await expect((0, config_index_1.main)()).rejects.toThrow('__EXIT__:1');
+        expect(uploadRunMock).not.toHaveBeenCalled();
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/missing <path\.json>/));
+    });
+    it.each(['help', '-h', '--help'])('prints usage for %s', async (helpFlag) => {
+        setArgv(helpFlag);
+        await (0, config_index_1.main)();
+        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-config/));
+    });
+    it('prints usage when no command is provided', async () => {
+        setArgv();
+        await (0, config_index_1.main)();
+        expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/Usage: flexplm-config/));
+    });
+    it('exits on an unknown command', async () => {
+        setArgv('bogus');
+        await expect((0, config_index_1.main)()).rejects.toThrow('__EXIT__:1');
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Unknown command: bogus/));
+    });
+});

package/lib/cli/template/config-template.json.template

@@ -0,0 +1,22 @@
+{
+  "orgName": "<ORG_NAME>",
+  "appIdentifier": "<APP_IDENTIFIER>",
+
+  "_availableAttributes": {
+    "_note": "Reference only — the connector never reads this key. Add any of the attributes below as real top-level keys if this org needs them, then delete this whole \"_availableAttributes\" block.",
+    "apiHost": "FlexPLM API host base URL (required for the connector to reach FlexPLM)",
+    "userName": "FlexPLM user name used for Basic Auth (required)",
+    "password": "FlexPLM password used for Basic Auth (required)",
+    "plmEnviornment": "Sent as the PLM_ENV header on every FlexPLM request",
+    "urlContext": "Path prefix for FlexPLM URLs. Default: '/Windchill'",
+    "csrfEndpoint": "CSRF token endpoint path. Default: '/servlet/rest/security/csrf'",
+    "vibeEventEndpoint": "Endpoint VibeIQ posts inbound events to. Default: '/rfa/vibeiq/vibeEvents'",
+    "itemPreDevelopmentLifecycleStages": "Item lifecycle stages during which items are not synced to FlexPLM. Default: ['concept']",
+    "identifierAtts": "Map of FlexPLM object class to identifier attribute name(s), e.g. { \"LCSProduct\": [\"itemNumber\"] }",
+    "LCSMaterial": "{ \"processAsItem\": true } routes LCSMaterial to item:material instead of custom-entity",
+    "sendMode": "Map of event type to send mode, e.g. { \"ASYNC_PUBLISH_SEASON\": \"vibeiqfile\" }",
+    "payloadDefaultAsArray": "Whether outbound payload values default to arrays. Default: true",
+    "flexplmConnect": "{ \"staticHeaders\": { ... } } adds custom static headers to every FlexPLM request",
+    "propertyMapping": "Reserved for custom property-mapping overrides"
+  }
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.3",
+  "version": "1.7.4-alpha.7bbda17",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "bin": {
-    "flexplm-mapping": "lib/cli/index.js"
+    "flexplm-mapping": "lib/cli/index.js",
+    "flexplm-config": "lib/cli/config-index.js"
   },
   "files": [
     "lib/**/*",

package/scripts/copy-template.js

@@ -2,9 +2,13 @@
 const fs = require('fs');
 const path = require('path');
 
-const SRC = path.join('src', 'cli', 'template', 'mapping-template.ts.template');
-const DST = path.join('lib', 'cli', 'template', 'mapping-template.ts.template');
+const TEMPLATES = ['mapping-template.ts.template', 'config-template.json.template'];
 
-fs.mkdirSync(path.dirname(DST), { recursive: true });
-fs.copyFileSync(SRC, DST);
-console.log(`Copied ${SRC} -> ${DST}`);
+for (const templateFilename of TEMPLATES) {
+  const SRC = path.join('src', 'cli', 'template', templateFilename);
+  const DST = path.join('lib', 'cli', 'template', templateFilename);
+
+  fs.mkdirSync(path.dirname(DST), { recursive: true });
+  fs.copyFileSync(SRC, DST);
+  console.log(`Copied ${SRC} -> ${DST}`);
+}