@pb33f/cowboy-components 0.7.18 → 0.8.0

package/dist/services/rodeo-service.js

@@ -11,7 +11,7 @@ export class RodeoService {
                 });
                 const apiResult = await roundupStats.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: 'unable to fetch roundup statistics' });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -21,7 +21,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: 'unable to get roundup results: ' + e });
+                reject({ detail: 'unable to get roundup results: ' + e });
             }
         });
     }
@@ -37,7 +37,7 @@ export class RodeoService {
                 });
                 const apiResult = await npmStats.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: `unable to fetch npm statistics for project ${project}` });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -47,7 +47,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: `unable to get npm statistics for project ${project}: ` + e });
+                reject({ detail: `unable to fetch npm statistics for project ${project}: ` + e });
             }
         });
     }
@@ -67,7 +67,7 @@ export class RodeoService {
                 });
                 const apiResult = await githubResult.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: `unable to fetch github statistics for project ${project}` });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -77,7 +77,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: `unable to get github statistics for project ${project}: ` + e });
+                reject({ detail: `unable to fetch github statistics for project ${project}: ` + e });
             }
         });
     }
@@ -93,7 +93,7 @@ export class RodeoService {
                 });
                 const apiResult = await githubResult.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: `unable to fetch github clone statistics for project ${project}` });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -103,7 +103,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: `unable to get github clone statistics for project ${project}: ` + e });
+                reject({ detail: `unable to fetch github clone statistics for project ${project}: ` + e });
             }
         });
     }
@@ -119,7 +119,7 @@ export class RodeoService {
                 });
                 const apiResult = await githubResult.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: `unable to fetch github stars statistics for project ${project}` });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -129,7 +129,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: `unable to get github stars statistics for project ${project}: ` + e });
+                reject({ detail: `unable to fetch github stars statistics for project ${project}: ` + e });
             }
         });
     }
@@ -145,7 +145,7 @@ export class RodeoService {
                 });
                 const apiResult = await githubResult.json();
                 if (!apiResult) {
-                    reject({ details: 'unable to send feedback' });
+                    reject({ detail: `unable to fetch docker pull statistics for project ${project}` });
                     return;
                 }
                 if (apiResult?.type && apiResult?.title && apiResult?.status) {
@@ -155,7 +155,7 @@ export class RodeoService {
                 resolve(apiResult);
             }
             catch (e) {
-                reject({ details: `unable to get docker pull statistics for project ${project}: ` + e });
+                reject({ detail: `unable to fetch docker pull statistics for project ${project}: ` + e });
             }
         });
     }

package/dist/services/timeline-service.d.ts

@@ -1,8 +1,18 @@
-import { ChangeHistory, SpecSummary } from "../model/timeline";
-import { GraphResponse } from "../model/graph";
+import { ChangeHistory, ChangeStatisticsResponse, CompareRequest, CompareResponse, PRChangeResponse, SpecSummary, ToolsCompareRequest, ToolsCompareResponse } from "../model/timeline.js";
+import { GraphResponse } from "../model/graph.js";
+import { Problem } from "../model/problem.js";
 export declare class TimelineService {
     static doctorEndpoint: string;
     static getSummary(): Promise<SpecSummary[]>;
     static fetchChange(changeId: string, report?: boolean): Promise<GraphResponse>;
     static fetchHistory(): Promise<ChangeHistory>;
+    static fetchOriginalSpec(changeId: string): Promise<string>;
+    static fetchModifiedSpec(changeId: string): Promise<string>;
+    static fetchMarkdownReport(changeId: string): Promise<string>;
+    static fetchMarkdownSource(changeId: string): Promise<string>;
+    static getPullRequests(): Promise<PRChangeResponse[]>;
+    static compareChanges(request: CompareRequest): Promise<CompareResponse>;
+    static toolsCompare(request: ToolsCompareRequest, brokerId?: string): Promise<ToolsCompareResponse>;
+    static fetchChangeViolations(changeId: string): Promise<Problem[]>;
+    static fetchChangeStatistics(changeId: string): Promise<ChangeStatisticsResponse>;
 }

package/dist/services/timeline-service.js

@@ -1,3 +1,5 @@
+import { Problem } from "../model/problem.js";
+import { HeaderService } from "./header-service.js";
 export class TimelineService {
     static async getSummary() {
         return new Promise(async (resolve, reject) => {
@@ -81,5 +83,332 @@ export class TimelineService {
             }
         });
     }
+    static async fetchOriginalSpec(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/original', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'text/plain'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch original spec' });
+                    return;
+                }
+                const originalSpec = await response.text();
+                if (!originalSpec) {
+                    reject({ detail: 'original spec is empty' });
+                    return;
+                }
+                resolve(originalSpec);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch original spec: ' + e });
+            }
+        });
+    }
+    static async fetchModifiedSpec(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/modified', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'text/plain'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch modified spec' });
+                    return;
+                }
+                const modifiedSpec = await response.text();
+                if (!modifiedSpec) {
+                    reject({ detail: 'modified spec is empty' });
+                    return;
+                }
+                resolve(modifiedSpec);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch modified spec: ' + e });
+            }
+        });
+    }
+    static async fetchMarkdownReport(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/html-report', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Accept': 'text/html'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch markdown report' });
+                    return;
+                }
+                const htmlReport = await response.text();
+                if (!htmlReport) {
+                    reject({ detail: 'markdown report is empty' });
+                    return;
+                }
+                resolve(htmlReport);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch markdown report: ' + e });
+            }
+        });
+    }
+    static async fetchMarkdownSource(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/markdown-report', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Accept': 'text/markdown'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch markdown source' });
+                    return;
+                }
+                const markdownSource = await response.text();
+                if (!markdownSource) {
+                    reject({ detail: 'markdown source is empty' });
+                    return;
+                }
+                resolve(markdownSource);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch markdown source: ' + e });
+            }
+        });
+    }
+    static async getPullRequests() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/pull-requests', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                if (!response.ok) {
+                    if (response.status === 404) {
+                        resolve([]);
+                        return;
+                    }
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch pull requests' });
+                    return;
+                }
+                const prData = await response.json();
+                if (!prData) {
+                    resolve([]);
+                    return;
+                }
+                resolve(prData);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch pull requests: ' + e });
+            }
+        });
+    }
+    static async compareChanges(request) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/compare', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(request)
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to compare changes' });
+                    return;
+                }
+                const comparisonData = await response.json();
+                if (!comparisonData) {
+                    reject({ detail: 'comparison result is empty' });
+                    return;
+                }
+                resolve(comparisonData);
+            }
+            catch (e) {
+                reject({ detail: 'unable to compare changes: ' + e });
+            }
+        });
+    }
+    static async toolsCompare(request, brokerId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/compare', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers,
+                    body: JSON.stringify(request)
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to compare spec' });
+                    return;
+                }
+                const result = await response.json();
+                if (!result) {
+                    reject({ detail: 'comparison result is empty' });
+                    return;
+                }
+                resolve(result);
+            }
+            catch (e) {
+                reject({ detail: 'unable to compare spec: ' + e });
+            }
+        });
+    }
+    static async fetchChangeViolations(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/violations', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch change violations' });
+                    return;
+                }
+                const data = await response.json();
+                if (!data || !data.violations) {
+                    resolve([]);
+                    return;
+                }
+                const problems = data.violations.map((v) => new Problem(v.category, v.jsonPath, v.endColumn, v.endLineNumber, v.message, v.severity, v.startColumn, v.startLineNumber, v.source, v.id, v.sourceLocation));
+                resolve(problems);
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch change violations: ' + e });
+            }
+        });
+    }
+    static async fetchChangeStatistics(changeId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const response = await fetch(TimelineService.doctorEndpoint + '/timeline/change/' + changeId + '/statistics', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    if (errorData?.type && errorData?.title && errorData?.status) {
+                        reject(errorData);
+                        return;
+                    }
+                    reject({ detail: 'unable to fetch change statistics' });
+                    return;
+                }
+                const data = await response.json();
+                if (!data) {
+                    reject({ detail: 'empty statistics response' });
+                    return;
+                }
+                const diagnostics = {
+                    statistics: {
+                        filesizeKb: 0,
+                        filesizeBytes: 0,
+                        specType: '',
+                        specFormat: '',
+                        version: '',
+                        references: 0,
+                        externalDocs: 0,
+                        schemas: 0,
+                        parameters: 0,
+                        links: 0,
+                        paths: 0,
+                        operations: 0,
+                        tags: 0,
+                        examples: 0,
+                        enums: 0,
+                        security: 0,
+                        overallScore: data.score,
+                        totalErrors: data.severity?.errors ?? 0,
+                        totalWarnings: data.severity?.warnings ?? 0,
+                        totalInfo: data.severity?.infos ?? 0,
+                        totalHints: 0,
+                        categoryStatistics: (data.categories || []).map((c) => ({
+                            categoryName: c.category,
+                            categoryId: c.category,
+                            numIssues: c.errors + c.warnings + c.infos,
+                            score: 0,
+                            errors: c.errors,
+                            warnings: c.warnings,
+                            info: c.infos,
+                            hints: 0
+                        }))
+                    },
+                    diagnosis: data.description || '',
+                    evaluation: data.grade || '',
+                    remainingCredit: 0
+                };
+                resolve({
+                    changeId: data.changeId,
+                    statistics: diagnostics,
+                    delta: data.delta
+                });
+            }
+            catch (e) {
+                reject({ detail: 'unable to fetch change statistics: ' + e });
+            }
+        });
+    }
 }
 TimelineService.doctorEndpoint = 'https://doctor.pb33f.io';

package/dist/services/wallet-service.d.ts

@@ -1,5 +1,5 @@
 import { Wallet } from "../model/wallet.js";
 export declare class WalletService {
     static doctorEndpoint: string;
-    static applyDailyCredit(): Promise<Wallet>;
+    static applyDailyCredit(brokerId: string): Promise<Wallet>;
 }

package/dist/services/wallet-service.js

@@ -1,10 +1,13 @@
+import { HeaderService } from "./header-service";
 export class WalletService {
-    static async applyDailyCredit() {
+    static async applyDailyCredit(brokerId) {
         return new Promise(async (resolve, reject) => {
             try {
+                const headers = HeaderService.buildDefaultHeaders(brokerId);
                 const response = await fetch(WalletService.doctorEndpoint + '/wallet/free-daily', {
                     method: 'GET',
                     credentials: 'include',
+                    headers: headers,
                 });
                 const data = await response.json();
                 if (data.type && data.title && data.status) {

package/dist/services/workspace-service.js

@@ -2,14 +2,28 @@ export class WorkspaceService {
     static async getWorkspaces() {
         return new Promise(async (resolve, reject) => {
             try {
-                const defaultRuleset = await fetch(WorkspaceService.doctorEndpoint + '/workspaces/list', {
+                const response = await fetch(WorkspaceService.doctorEndpoint + '/workspaces/list', {
                     method: 'GET',
                     credentials: 'include',
                     headers: {
                         'Content-Type': 'application/json'
                     },
                 });
-                const apiResult = await defaultRuleset.json();
+                if (!response.ok) {
+                    try {
+                        const errorResult = await response.json();
+                        reject(errorResult);
+                    }
+                    catch {
+                        reject({ detail: `HTTP ${response.status}: ${response.statusText}` });
+                    }
+                    return;
+                }
+                if (response.status === 204) {
+                    resolve({ response: [] });
+                    return;
+                }
+                const apiResult = await response.json();
                 if (!apiResult) {
                     reject({ detail: 'unable to fetch list of workspaces, cannot decode JSON' });
                     return;