@nu-art/jira-backend 0.400.7

package/core/module-pack.d.ts

@@ -0,0 +1 @@
+export declare const ModulePack_Backend_Jira: import("../modules/JiraModule.js").ModuleBE_Jira_Class[];

package/core/module-pack.js

@@ -0,0 +1,22 @@
+/*
+ * Permissions management system, define access level for each of
+ * your server apis, and restrict users by giving them access levels
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { JiraModule } from '../modules/JiraModule.js';
+export const ModulePack_Backend_Jira = [
+    JiraModule
+];

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core/module-pack.js";
+export * from "./modules/JiraModule.js";
+export * from "./modules/utils.js";

package/index.js

@@ -0,0 +1,21 @@
+/*
+ * Permissions management system, define access level for each of
+ * your server apis, and restrict users by giving them access levels
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from "./core/module-pack.js";
+export * from "./modules/JiraModule.js";
+export * from "./modules/utils.js";

package/modules/JiraModule.d.ts

@@ -0,0 +1,128 @@
+import { Module, TypedMap } from '@nu-art/ts-common';
+import { JiraIssueText } from './utils.js';
+import { JiraVersion } from '@nu-art/jira-shared/version';
+type Config = {
+    auth: JiraAuth;
+    defaultAssignee: JiraUser;
+    baseUrl?: string;
+};
+type JiraAuth = {
+    email: string;
+    apiKey: string;
+};
+type JiraUser = {
+    accountId: string;
+    name?: string;
+    email?: string;
+};
+type JiraMark = {
+    type: string;
+    attrs: {
+        href: string;
+    };
+};
+type JiraContent = {
+    type: 'paragraph' | string;
+    text?: string;
+    marks?: JiraMark[];
+    content?: JiraContent[];
+};
+type JiraDescription = string | {
+    type: 'doc' | string;
+    version: number;
+    content: JiraContent[];
+};
+export type JiraIssue_Fields = {
+    project: JiraProject;
+    issuetype: IssueType;
+    description: JiraDescription;
+    summary: string;
+    reporter?: {
+        id: string;
+    };
+} & TypedMap<any>;
+export type IssueType = {
+    id?: string;
+    name: string;
+};
+export type LabelType = {
+    label: string[];
+};
+export type JiraProject = {
+    id: string;
+    name: string;
+    key: string;
+};
+export type BaseIssue = {
+    id: string;
+    key: string;
+    self: string;
+    url: string;
+};
+export type JiraIssue = BaseIssue & {
+    expand: string;
+    fields: JiraIssue_Fields;
+};
+export type FixVersionType = {
+    fixVersions: {
+        name: string;
+    }[];
+};
+export type QueryItemWithOperator = {
+    value: string;
+    operator: string;
+};
+export type JiraQuery = TypedMap<string | string[] | QueryItemWithOperator> & {
+    status?: string | string[];
+    project?: string | string[];
+    fixVersion?: string | string[];
+};
+export type JiraResponse_IssuesQuery = {
+    expand: string;
+    startAt: number;
+    maxResults: number;
+    total: number;
+    issues: JiraIssue[];
+};
+export type ResponsePostIssue = BaseIssue;
+export declare class ModuleBE_Jira_Class extends Module<Config> {
+    private headersJson;
+    private headersForm;
+    private projects;
+    private versions;
+    private restUrl;
+    protected init(): void;
+    private buildHeaders;
+    project: {
+        query: (projectKey: string) => Promise<JiraProject>;
+    };
+    version: {
+        query: (projectId: string, versionName: string) => Promise<JiraVersion | undefined>;
+        create: (projectId: string, versionName: string) => Promise<JiraVersion>;
+    };
+    comment: {
+        add: (issueKey: string, comment: string) => Promise<unknown>;
+    };
+    issue: {
+        query: (query: JiraQuery) => Promise<JiraIssue[]>;
+        get: (issueId: string) => Promise<JiraIssue>;
+        comment: {
+            add: (issueKey: string, comment: string) => Promise<unknown>;
+        };
+        create: (project: JiraProject, issueType: IssueType, summary: string, descriptions: JiraIssueText[], label: string[]) => Promise<ResponsePostIssue>;
+        update: (issueKey: string, fields: Partial<JiraIssue_Fields>) => Promise<unknown>;
+        resolve: (issueKey: string, projectKey: string, versionName: string, status: string) => Promise<unknown>;
+    };
+    getIssueTypes: (id: string) => Promise<unknown>;
+    query: (query: JiraQuery) => Promise<JiraIssue[]>;
+    getIssueRequest: (issueId: string) => Promise<JiraIssue>;
+    addIssueAttachment: (issue: string, file: Buffer) => Promise<unknown>;
+    private executeFormRequest;
+    private executePostRequest;
+    private executePutRequest;
+    private handleResponse;
+    private executeGetRequest;
+    private executeRequest;
+}
+export declare const JiraModule: ModuleBE_Jira_Class;
+export {};

package/modules/JiraModule.js

@@ -0,0 +1,191 @@
+/*
+ * Permissions management system, define access level for each of
+ * your server apis, and restrict users by giving them access levels
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ApiException, BadImplementationException, composeUrl, ImplementationMissingException, MimeType_json, Module } from '@nu-art/ts-common';
+import { promisifyRequest } from '@nu-art/thunderstorm-backend';
+import { JiraUtils } from './utils.js';
+import { HeaderKey_ContentType, HttpMethod } from '@nu-art/thunderstorm-shared';
+const createFormData = (filename, buffer) => ({ file: { value: buffer, options: { filename } } });
+export class ModuleBE_Jira_Class extends Module {
+    headersJson;
+    headersForm;
+    projects;
+    versions = {};
+    restUrl;
+    init() {
+        if (!this.config.baseUrl)
+            throw new ImplementationMissingException('Missing Jira baseUrl for JiraModule, please add the key baseUrl to the config');
+        this.restUrl = this.config.baseUrl + '/rest/api/3';
+        this.logInfo(`Rest URL: ${this.restUrl}`);
+        if (!this.config.auth || !this.config.auth.apiKey || !this.config.auth.email)
+            throw new ImplementationMissingException('Missing auth config variables for JiraModule');
+        this.headersJson = this.buildHeaders(this.config.auth, true);
+        this.headersForm = this.buildHeaders(this.config.auth, false);
+    }
+    buildHeaders = ({ apiKey, email }, check) => {
+        const headers = {
+            Authorization: `Basic ${Buffer.from(email + ':' + apiKey).toString('base64')}`
+        };
+        if (!check) {
+            headers['X-Atlassian-Token'] = 'no-check';
+            headers[HeaderKey_ContentType] = 'multipart/form-data';
+        }
+        else {
+            headers.Accept = MimeType_json;
+            headers[HeaderKey_ContentType] = MimeType_json;
+        }
+        return headers;
+    };
+    project = {
+        query: async (projectKey) => {
+            if (!this.projects)
+                this.projects = await this.executeGetRequest(`/project`);
+            const project = this.projects.find(_project => _project.key === projectKey);
+            if (!project)
+                throw new BadImplementationException(`Could not find project: ${projectKey}`);
+            return project;
+        },
+    };
+    version = {
+        query: async (projectId, versionName) => {
+            if (!this.versions[projectId])
+                this.versions[projectId] = await this.executeGetRequest(`/project/${projectId}/versions`);
+            return this.versions[projectId].find(version => version.name === versionName);
+        },
+        create: async (projectId, versionName) => {
+            const version = await this.executePostRequest(`/version`, {
+                projectId,
+                name: versionName
+            });
+            this.versions[projectId].push(version);
+            return version;
+        }
+    };
+    comment = {
+        add: async (issueKey, comment) => {
+            return this.executePostRequest(`/issue/${issueKey}/comment`, JiraUtils.createText(comment));
+        }
+    };
+    issue = {
+        query: async (query) => {
+            return (await this.executeGetRequest(`/search`, { jql: JiraUtils.buildJQL(query) })).issues;
+        },
+        get: async (issueId) => {
+            return this.executeGetRequest(`/issue/${issueId}`);
+        },
+        comment: this.comment,
+        create: async (project, issueType, summary, descriptions, label) => {
+            const issue = await this.executePostRequest('/issue', {
+                fields: {
+                    project,
+                    issuetype: issueType,
+                    description: JiraUtils.createText(...descriptions),
+                    summary,
+                    labels: label,
+                    assignee: {
+                        accountId: this.config.defaultAssignee.accountId
+                    }
+                }
+            });
+            issue.url = `${this.config.baseUrl}/browse/${issue.key}`;
+            return issue;
+        },
+        update: async (issueKey, fields) => {
+            return this.executePutRequest(`/issue/${issueKey}`, { fields });
+        },
+        resolve: async (issueKey, projectKey, versionName, status) => {
+            const project = await JiraModule.project.query(projectKey);
+            let version = await JiraModule.version.query(projectKey, versionName);
+            if (!version)
+                version = await JiraModule.version.create(project.id, versionName);
+            return this.executePutRequest(`/issue/${issueKey}`, { fields: { fixVersions: [{ id: version.id }] } });
+        },
+    };
+    getIssueTypes = async (id) => {
+        return this.executeGetRequest('/issue/createmetadata', { projectKeys: id });
+    };
+    query = async (query) => {
+        return (await this.executeGetRequest(`/search`, { jql: JiraUtils.buildJQL(query) })).issues;
+    };
+    getIssueRequest = async (issueId) => {
+        return this.executeGetRequest(`/issue/${issueId}`);
+    };
+    addIssueAttachment = async (issue, file) => {
+        return this.executeFormRequest(`/issue/${issue}/attachments`, file);
+    };
+    executeFormRequest = async (url, buffer) => {
+        const request = {
+            headers: this.headersForm,
+            uri: `${this.restUrl}${url}`,
+            formData: createFormData('logs.zip', buffer),
+            method: HttpMethod.POST,
+        };
+        return this.executeRequest(request);
+    };
+    async executePostRequest(url, body, label) {
+        const request = {
+            headers: this.headersJson,
+            uri: `${this.restUrl}${url}`,
+            body,
+            method: HttpMethod.POST,
+            json: true
+        };
+        return this.executeRequest(request);
+    }
+    async executePutRequest(url, body) {
+        const request = {
+            headers: this.headersJson,
+            uri: `${this.restUrl}${url}`,
+            body,
+            method: HttpMethod.PUT,
+            json: true
+        };
+        return this.executeRequest(request);
+    }
+    // async executeGetRequestNew<T>(url: string, _params?: { [k: string]: string }): Promise<T> {
+    // 	if (!this.restUrl)
+    // 		throw new ImplementationMissingException('Need a baseUrl');
+    //
+    // 	return AxiosHttpModule
+    // 		.createRequest(HttpMethod.GET, generateHex(8))
+    // 		.setOrigin(this.restUrl)
+    // 		.setUrl(url)
+    // 		.setUrlParams(_params)
+    // 		.setHeaders(this.headersJson)
+    // 		.executeSync();
+    // }
+    handleResponse(response) {
+        if (`${response.statusCode}`[0] !== '2')
+            throw new ApiException(response.statusCode, response.body);
+        return response.toJSON().body;
+    }
+    async executeGetRequest(url, _params) {
+        const request = {
+            headers: this.headersJson,
+            uri: `${composeUrl(`${this.restUrl}${url}`, _params)}`,
+            method: HttpMethod.GET,
+            json: true
+        };
+        return this.executeRequest(request);
+    }
+    async executeRequest(request) {
+        const response = await promisifyRequest(request, false);
+        return this.handleResponse(response);
+    }
+}
+export const JiraModule = new ModuleBE_Jira_Class();

package/modules/utils.d.ts

@@ -0,0 +1,32 @@
+import { JiraQuery } from "./JiraModule.js";
+export type JiraIssueText = string | {
+    href: string;
+    text: string;
+};
+declare function createText(...texts: JiraIssueText[]): {
+    type: string;
+    version: number;
+    content: {
+        type: string;
+        content: ({
+            type: string;
+            text: string;
+            marks?: undefined;
+        } | {
+            type: string;
+            text: string;
+            marks: {
+                type: string;
+                attrs: {
+                    href: string;
+                };
+            }[];
+        })[];
+    }[];
+};
+declare function buildJQL(query: JiraQuery): string;
+export declare const JiraUtils: {
+    createText: typeof createText;
+    buildJQL: typeof buildJQL;
+};
+export {};

package/modules/utils.js

@@ -0,0 +1,72 @@
+/*
+ * Permissions management system, define access level for each of
+ * your server apis, and restrict users by giving them access levels
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { _keys } from "@nu-art/ts-common";
+function createText(...texts) {
+    return {
+        type: "doc",
+        version: 1,
+        content: [
+            {
+                type: "paragraph",
+                content: texts.map(text => {
+                    if (typeof text === "string")
+                        return {
+                            type: "text",
+                            text
+                        };
+                    return {
+                        type: "text",
+                        text: text.text,
+                        marks: [
+                            {
+                                type: "link",
+                                attrs: {
+                                    href: text.href
+                                }
+                            }
+                        ]
+                    };
+                })
+            }
+        ]
+    };
+}
+function buildJQL(query) {
+    const params = _keys(query).map((key) => {
+        let queryValue;
+        let operator = '=';
+        if (Array.isArray(query[key])) {
+            queryValue = query[key].map(value => `"${value}"`).join(",");
+            queryValue = `(${queryValue})`;
+        }
+        else if (typeof query[key] === 'object') {
+            const queryItemWithOperator = query[key];
+            queryValue = `"${queryItemWithOperator.value}"`;
+            operator = queryItemWithOperator.operator;
+        }
+        else
+            queryValue = `"${query[key]}"`;
+        return `${key}${operator}${queryValue}`;
+    });
+    return params.join(" and ");
+}
+export const JiraUtils = {
+    createText,
+    buildJQL,
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@nu-art/jira-backend",
+  "version": "0.400.7",
+  "description": "Jira api Module Backend",
+  "keywords": [
+    "TacB0sS",
+    "backend",
+    "boilerplate",
+    "Jira",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm-boilerplate.git"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "dependencies": {
+    "@nu-art/jira-shared": "0.400.7",
+    "@nu-art/firebase-backend": "0.400.7",
+    "@nu-art/firebase-shared": "0.400.7",
+    "@nu-art/thunderstorm-backend": "0.400.7",
+    "@nu-art/thunderstorm-shared": "0.400.7",
+    "@nu-art/ts-common": "0.400.7",
+    "body-parser": "^1.18.3",
+    "compression": "^1.7.4",
+    "express": "^4.18.2",
+    "firebase-admin": "13.4.0",
+    "moment": "^2.29.4",
+    "request": "^2.88.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.2",
+    "@types/express": "^4.17.17",
+    "@types/js-base64": "^2.3.1",
+    "@types/request": "^2.48.3",
+    "@types/saml2-js": "^1.6.8"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}