@hahnpro/hpc-api 2025.3.3 → 2025.3.5

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @hahnpro/hpc-api
 
+## 2025.3.4
+
+Added `addOrganizationMembers`, `addSubscriptionToOrganization` and `getOrganizationIdByName` methods to Organizations API service
+
 ## 2025.3.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2025.3.3",
+  "version": "2025.3.5",
   "description": "Module for easy access to the HahnPRO Cloud API",
   "license": "MIT",
   "author": {

package/src/index.d.ts

@@ -11,7 +11,9 @@ export * from './lib/http.service';
 export * from './lib/label.interface';
 export * from './lib/mock';
 export * from './lib/notification.interface';
+export * from './lib/organization.interface';
 export * from './lib/schema.interface';
 export * from './lib/secret.interface';
 export * from './lib/task.interface';
 export * from './lib/vault.interface';
+export * from './lib/task.service';

package/src/index.js

@@ -13,7 +13,9 @@ tslib_1.__exportStar(require("./lib/http.service"), exports);
 tslib_1.__exportStar(require("./lib/label.interface"), exports);
 tslib_1.__exportStar(require("./lib/mock"), exports);
 tslib_1.__exportStar(require("./lib/notification.interface"), exports);
+tslib_1.__exportStar(require("./lib/organization.interface"), exports);
 tslib_1.__exportStar(require("./lib/schema.interface"), exports);
 tslib_1.__exportStar(require("./lib/secret.interface"), exports);
 tslib_1.__exportStar(require("./lib/task.interface"), exports);
 tslib_1.__exportStar(require("./lib/vault.interface"), exports);
+tslib_1.__exportStar(require("./lib/task.service"), exports);

package/src/lib/data.service.d.ts

@@ -23,5 +23,5 @@ export declare class DataService<T> extends APIBase implements DataInterface<T>
         [key: string]: any;
     }): Promise<T>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
-    private getFilterString;
+    protected getFilterString(filter: Filter): string;
 }

package/src/lib/http.service.d.ts

@@ -35,6 +35,7 @@ export declare class HttpClient {
     get: <T>(url: string, config?: Config) => Promise<T>;
     post: <T>(url: string, data: any, config?: Config) => Promise<T>;
     put: <T>(url: string, data: any, config?: Config) => Promise<T>;
+    patch: <T>(url: string, data: any, config?: Config) => Promise<T>;
     protected request: <T>(method: Method, url: string, config?: Config, data?: any) => Promise<T>;
     addEventSource(url: string, listener: (event: MessageEvent) => void, errorListener?: (event: MessageEvent) => void, options?: TokenOption): Promise<string>;
     destroyEventSource(id: string): void;

package/src/lib/http.service.js

@@ -22,6 +22,7 @@ class HttpClient {
         this.get = (url, config) => this.request('GET', url, config);
         this.post = (url, data, config) => this.request('POST', url, config, data);
         this.put = (url, data, config) => this.request('PUT', url, config, data);
+        this.patch = (url, data, config) => this.request('PATCH', url, config, data);
         this.request = (method, url, config = {}, data) => {
             return this.requestQueue.add(() => new Promise((resolve, reject) => {
                 const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();

package/src/lib/mock/asset.mock.service.d.ts

@@ -1,5 +1,5 @@
 import FormData from 'form-data';
-import { Paginated, RequestParameter } from '../data.interface';
+import { Filter, Paginated, RequestParameter } from '../data.interface';
 import { TokenOption } from '../http.service';
 import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from '../interfaces';
 import { AssetService } from '../services';
@@ -17,6 +17,7 @@ export declare class AssetMockService extends BaseService implements AssetServic
     constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);
     private getAssets;
     addOne(dto: Asset): Promise<Asset>;
+    count(filter: Filter, options?: TokenOption): Promise<number>;
     deleteOne(assetId: string, force?: boolean): Promise<Asset>;
     getMany(params?: RequestParameter): Promise<Paginated<Asset[]>>;
     updateOne(assetId: string, dto: Asset): Promise<Asset>;
@@ -30,5 +31,6 @@ export declare class AssetMockService extends BaseService implements AssetServic
     deleteRevision(assetId: string, revisionId: string): Promise<any>;
     findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
     updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Asset[]>>;
 }
 export {};

package/src/lib/mock/asset.mock.service.js

@@ -30,6 +30,9 @@ class AssetMockService extends BaseService {
         this.revisions.push({ ...dto, originalId: dto.id });
         return super.addOne(dto);
     }
+    count(filter, options = {}) {
+        return Promise.resolve(this.data.length);
+    }
     deleteOne(assetId, force = false) {
         const asset = this.data.find((v) => v.id === assetId);
         if (!asset?.deletedAt && !force) {
@@ -120,5 +123,13 @@ class AssetMockService extends BaseService {
         this.data[index] = { ...asset, ...dto };
         return Promise.resolve(this.data[index]);
     }
+    findByName(name, options = {}) {
+        const docs = this.data.filter((asset) => asset.name === name);
+        return Promise.resolve({
+            docs,
+            total: docs.length,
+            limit: Number.MAX_SAFE_INTEGER,
+        });
+    }
 }
 exports.AssetMockService = AssetMockService;

package/src/lib/mock/flow-deployment.mock.service.js

@@ -112,8 +112,9 @@ class FlowDeploymentMockService extends BaseService {
     async getReferences(properties) {
         // super simplified version of real resolver
         return Promise.all(Object.keys(properties).map(async (prop) => {
-            if (prop !== 'assetId')
+            if (prop !== 'assetId') {
                 throw new Error('not implemented');
+            }
             return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
         }));
     }

package/src/lib/mock/organization.mock.service.d.ts

@@ -1,7 +1,10 @@
-import { Organization } from '../organization.interface';
+import { Organization, OrganizationName, SubscriptionType, UserWithOrgRoles } from '../organization.interface';
 import { OrganizationService } from '../organization.service';
 import { DataMockService } from './data.mock.service';
 export declare class OrganizationMockService extends DataMockService<Organization> implements OrganizationService {
     constructor(organizations: Organization[]);
     addOrganizationInvitation(id: string, email: string, roles: string[]): Promise<void>;
+    addOrganizationMembers(id: string, usersWithOrgRoles: UserWithOrgRoles[]): Promise<void>;
+    addSubscriptionToOrganization(id: string, type: SubscriptionType): Promise<Organization>;
+    getOrganizationIdByName(name: string): Promise<OrganizationName>;
 }

package/src/lib/mock/organization.mock.service.js

@@ -9,9 +9,36 @@ class OrganizationMockService extends data_mock_service_1.DataMockService {
     }
     addOrganizationInvitation(id, email, roles) {
         if (!id || !email || !roles?.length) {
-            return Promise.reject();
+            return Promise.reject('Bad Request');
         }
         return Promise.resolve();
     }
+    addOrganizationMembers(id, usersWithOrgRoles) {
+        if (!id ||
+            !usersWithOrgRoles?.length ||
+            usersWithOrgRoles.some((userWithOrgRoles) => !userWithOrgRoles.username || !userWithOrgRoles.orgRoles?.length)) {
+            return Promise.reject('Bad Request');
+        }
+        return Promise.resolve();
+    }
+    addSubscriptionToOrganization(id, type) {
+        if (!id || !type) {
+            return Promise.reject('Bad Request');
+        }
+        const organization = this.data.find((org) => org.id === id);
+        if (!organization) {
+            return Promise.reject('Not Found');
+        }
+        const existingId = organization.subscriptionId;
+        if (existingId) {
+            organization.previousSubscriptions = [existingId, ...(organization.previousSubscriptions || [])];
+        }
+        organization.subscriptionId = `test-subscription-${organization.previousSubscriptions?.length || 0}`;
+        return Promise.resolve(organization);
+    }
+    getOrganizationIdByName(name) {
+        const id = this.data.find((org) => org.name === name)?.id;
+        return Promise.resolve({ id });
+    }
 }
 exports.OrganizationMockService = OrganizationMockService;

package/src/lib/mock/task.mock.service.d.ts

@@ -1,5 +1,6 @@
 import { Paginated, RequestParameter } from '../data.interface';
-import { Task } from '../task.interface';
+import { TokenOption } from '../http.service';
+import { LogbookEntry, LogbookEntryDto, Task } from '../task.interface';
 import { TaskService } from '../task.service';
 import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
@@ -9,9 +10,21 @@ interface BaseService extends DataMockService<Task>, TrashMockService<Task> {
 declare class BaseService extends APIBaseMock<Task> {
 }
 export declare class TaskMockService extends BaseService implements TaskService {
-    constructor(tasks: Task[]);
+    private entries;
+    constructor(tasks: Task[], logbookEntries?: LogbookEntry[]);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
     deleteOne(taskId: string, force?: boolean): Promise<Task>;
     getMany(params?: RequestParameter): Promise<Paginated<Task[]>>;
+    findByName(name: string, options?: any): Promise<Paginated<Task[]>>;
+    findByAsset(assetId: string, options?: any): Promise<Paginated<Task[]>>;
+    getLogbookEntries(taskId: string, limit?: number, offset?: number, _options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
+    addLogbookEntry(taskId: string, dto: LogbookEntryDto, _options?: TokenOption): Promise<LogbookEntry>;
+    updateLogbookEntry(taskId: string, entryId: string, dto: Partial<LogbookEntryDto>, _options?: TokenOption): Promise<LogbookEntry>;
+    deleteLogbookEntry(taskId: string, entryId: string, _options?: TokenOption): Promise<{
+        deleted: boolean;
+    }>;
+    getUserLogbookEntries(limit?: number, offset?: number, _options?: TokenOption, userId?: string): Promise<Paginated<LogbookEntry[]>>;
+    seed(entries: LogbookEntry[]): void;
+    clear(): void;
 }
 export {};

package/src/lib/mock/task.mock.service.js

@@ -12,8 +12,10 @@ BaseService = tslib_1.__decorate([
     (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
 ], BaseService);
 class TaskMockService extends BaseService {
-    constructor(tasks) {
+    constructor(tasks, logbookEntries = []) {
         super(tasks);
+        this.entries = [];
+        this.entries = [...logbookEntries];
     }
     async createTaskAttachedToAsset(dto) {
         this.data.push(dto);
@@ -32,5 +34,94 @@ class TaskMockService extends BaseService {
         const page = this.getItems(params, false);
         return Promise.resolve(page);
     }
+    findByName(name, options = {}) {
+        const filtered = this.data.filter((task) => task.name === name);
+        const result = {
+            docs: filtered,
+            total: filtered.length,
+            page: 1,
+            limit: filtered.length,
+        };
+        return Promise.resolve(result);
+    }
+    findByAsset(assetId, options = {}) {
+        const filtered = this.data.filter((task) => task.assetRef === assetId);
+        const result = {
+            docs: filtered,
+            total: filtered.length,
+            page: 1,
+            limit: filtered.length,
+        };
+        return Promise.resolve(result);
+    }
+    // override network methods to in‑memory versions
+    async getLogbookEntries(taskId, limit = 50, offset = 0, _options = {}) {
+        const taskEntries = this.entries.filter((e) => e.taskId === taskId);
+        const docs = taskEntries.slice(offset, offset + limit);
+        return {
+            docs,
+            limit,
+            offset,
+            total: taskEntries.length,
+            page: Math.floor(offset / limit) + 1,
+            pages: Math.max(1, Math.ceil(taskEntries.length / limit)),
+        };
+    }
+    async addLogbookEntry(taskId, dto, _options = {}) {
+        const id = globalThis.crypto?.randomUUID?.() || Math.random().toString(36).slice(2);
+        const now = new Date().toISOString();
+        const entry = {
+            id,
+            taskId,
+            date: dto.date || now,
+            duration: dto.duration ?? 0,
+            materials: dto.materials || [],
+            comment: dto.comment || '',
+            source: 'manual',
+            createdAt: now,
+            updatedAt: now,
+            createdBy: dto.createdBy || { id: 'mock-user', username: 'mock-user' },
+        };
+        this.entries.push(entry);
+        return entry;
+    }
+    async updateLogbookEntry(taskId, entryId, dto, _options = {}) {
+        const idx = this.entries.findIndex((e) => e.id === entryId && e.taskId === taskId);
+        if (idx === -1) {
+            throw new Error('Not found');
+        }
+        const updated = {
+            ...this.entries[idx],
+            ...dto,
+            materials: dto.materials !== undefined ? dto.materials : this.entries[idx].materials,
+            updatedAt: new Date().toISOString(),
+        };
+        this.entries[idx] = updated;
+        return updated;
+    }
+    async deleteLogbookEntry(taskId, entryId, _options = {}) {
+        const before = this.entries.length;
+        this.entries = this.entries.filter((e) => !(e.id === entryId && e.taskId === taskId));
+        return { deleted: this.entries.length < before };
+    }
+    async getUserLogbookEntries(limit = 50, offset = 0, _options = {}, userId = 'mock-user') {
+        const userEntries = this.entries.filter((e) => e.createdBy?.id === userId);
+        const docs = userEntries.slice(offset, offset + limit);
+        return {
+            docs,
+            limit,
+            offset,
+            total: userEntries.length,
+            page: Math.floor(offset / limit) + 1,
+            pages: Math.max(1, Math.ceil(userEntries.length / limit)),
+        };
+    }
+    // test helpers
+    seed(entries) {
+        this.entries = [...entries];
+    }
+    clear() {
+        this.entries = [];
+    }
 }
 exports.TaskMockService = TaskMockService;

package/src/lib/organization.interface.d.ts

@@ -24,3 +24,13 @@ export interface Organization {
     createdBy?: Author;
     updatedBy?: Author;
 }
+export interface OrganizationName {
+    id: string;
+    name?: string;
+    isDeleted?: boolean;
+}
+export interface UserWithOrgRoles {
+    username: string;
+    orgRoles: string[];
+}
+export type SubscriptionType = 'dev' | 'free' | 'inactive' | 'pro';

package/src/lib/organization.service.d.ts

@@ -1,7 +1,10 @@
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
-import { Organization } from './organization.interface';
+import { Organization, OrganizationName, SubscriptionType, UserWithOrgRoles } from './organization.interface';
 export declare class OrganizationService extends DataService<Organization> {
     constructor(httpClient: HttpClient);
     addOrganizationInvitation(id: string, email: string, roles: string[]): Promise<void>;
+    addOrganizationMembers(id: string, usersWithOrgRoles: UserWithOrgRoles[]): Promise<void>;
+    addSubscriptionToOrganization(id: string, type: SubscriptionType): Promise<Organization>;
+    getOrganizationIdByName(name: string): Promise<OrganizationName>;
 }

package/src/lib/organization.service.js

@@ -9,5 +9,14 @@ class OrganizationService extends data_service_1.DataService {
     addOrganizationInvitation(id, email, roles) {
         return this.httpClient.post(`${this.basePath}/${id}/data/invitations`, { roles, email });
     }
+    addOrganizationMembers(id, usersWithOrgRoles) {
+        return this.httpClient.post(`${this.basePath}/${id}/members`, { usersWithOrgRoles });
+    }
+    addSubscriptionToOrganization(id, type) {
+        return this.httpClient.post(`${this.basePath}/${id}/subscription`, { type });
+    }
+    getOrganizationIdByName(name) {
+        return this.httpClient.get(`${this.basePath}/names/${name}`);
+    }
 }
 exports.OrganizationService = OrganizationService;

package/src/lib/services/asset.service.d.ts

@@ -1,6 +1,6 @@
 import FormData from 'form-data';
 import { APIBase } from '../api-base';
-import { Paginated, RequestParameter } from '../data.interface';
+import { Filter, Paginated, RequestParameter } from '../data.interface';
 import { DataService } from '../data.service';
 import { HttpClient, TokenOption } from '../http.service';
 import { Asset, AssetRevision, Attachment, EventCause, EventLevelOverride } from '../interfaces';
@@ -11,6 +11,7 @@ declare class BaseService extends APIBase {
 }
 export declare class AssetService extends BaseService {
     constructor(httpClient: HttpClient);
+    count(filter: Filter, options?: TokenOption): Promise<number>;
     deleteOne(id: string, force?: boolean, options?: TokenOption): Promise<any>;
     addAttachment: (id: string, form: FormData, options?: TokenOption) => Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter, options?: TokenOption): Promise<Paginated<Asset[]>>;
@@ -22,5 +23,6 @@ export declare class AssetService extends BaseService {
     deleteRevision(assetId: string, revisionId: string, options?: TokenOption): Promise<any>;
     findOneExternal(key: string, options?: TokenOption): Promise<Asset>;
     updateOneExternal(key: string, dto: any, options?: TokenOption): Promise<Asset>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Asset[]>>;
 }
 export {};

package/src/lib/services/asset.service.js

@@ -24,6 +24,10 @@ class AssetService extends BaseService {
             });
         };
     }
+    count(filter, options = {}) {
+        const params = { filter: this.getFilterString(filter) };
+        return this.httpClient.get(`${this.basePath}/count`, { params, ...options });
+    }
     deleteOne(id, force = false, options = {}) {
         return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force }, ...options });
     }
@@ -54,5 +58,8 @@ class AssetService extends BaseService {
     updateOneExternal(key, dto, options = {}) {
         return this.httpClient.put(`${this.basePath}/external/${key}`, dto, options);
     }
+    findByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}?name=${encodeURIComponent(name)}`, options);
+    }
 }
 exports.AssetService = AssetService;

package/src/lib/task.interface.d.ts

@@ -1,3 +1,4 @@
+import { Author } from './interfaces/resource.interface';
 export interface Task {
     id: string;
     name: string;
@@ -21,3 +22,30 @@ export interface Task {
     updatedAt?: string;
     deletedAt?: string;
 }
+export interface LogbookEntry {
+    id: string;
+    taskId: string;
+    date: string;
+    duration: number;
+    materials: {
+        name: string;
+        quantity: number;
+    }[];
+    comment?: string;
+    source: 'manual' | 'voice' | 'automatic';
+    createdBy: Author;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LogbookEntryDto {
+    date: string;
+    duration: number;
+    materials: {
+        name: string;
+        quantity: number;
+    }[];
+    comment?: string;
+    source?: 'manual' | 'voice' | 'automatic';
+    taskId: string;
+    createdBy?: Author;
+}

package/src/lib/task.service.d.ts

@@ -1,7 +1,8 @@
 import { APIBase } from './api-base';
+import { Paginated } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient, TokenOption } from './http.service';
-import { Task } from './task.interface';
+import { LogbookEntry, LogbookEntryDto, Task } from './task.interface';
 import { TrashService } from './trash.service';
 interface BaseService extends DataService<Task>, TrashService<Task> {
 }
@@ -10,5 +11,14 @@ declare class BaseService extends APIBase {
 export declare class TaskService extends BaseService {
     constructor(httpClient: HttpClient);
     createTaskAttachedToAsset(dto: any, options?: TokenOption): Promise<Task>;
+    findByName(name: string, options?: TokenOption): Promise<Paginated<Task[]>>;
+    findByAsset(assetId: string, options?: TokenOption): Promise<Paginated<Task[]>>;
+    getLogbookEntries(taskId: string, limit?: number, offset?: number, options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
+    addLogbookEntry(taskId: string, entry: LogbookEntryDto, options?: TokenOption): Promise<LogbookEntry>;
+    updateLogbookEntry(taskId: string, entryId: string, entry: Partial<LogbookEntryDto>, options?: TokenOption): Promise<LogbookEntry>;
+    deleteLogbookEntry(taskId: string, entryId: string, options?: TokenOption): Promise<{
+        deleted: boolean;
+    }>;
+    getUserLogbookEntries(limit?: number, offset?: number, options?: TokenOption): Promise<Paginated<LogbookEntry[]>>;
 }
 export {};

package/src/lib/task.service.js

@@ -19,5 +19,32 @@ class TaskService extends BaseService {
     createTaskAttachedToAsset(dto, options = {}) {
         return this.httpClient.post(this.basePath, dto, options);
     }
+    findByName(name, options = {}) {
+        return this.httpClient.get(`${this.basePath}?name=${encodeURIComponent(name)}`, options);
+    }
+    findByAsset(assetId, options = {}) {
+        return this.httpClient.get(`${this.basePath}?assetRef=${assetId}`, options);
+    }
+    getLogbookEntries(taskId, limit = 50, offset = 0, options = {}) {
+        return this.httpClient.get(`${this.basePath}/${taskId}/logbook`, {
+            ...options,
+            params: { limit: String(limit), offset: String(offset) },
+        });
+    }
+    addLogbookEntry(taskId, entry, options = {}) {
+        return this.httpClient.post(`${this.basePath}/${taskId}/logbook`, entry, options);
+    }
+    updateLogbookEntry(taskId, entryId, entry, options = {}) {
+        return this.httpClient.patch(`${this.basePath}/${taskId}/logbook/${entryId}`, entry, options);
+    }
+    deleteLogbookEntry(taskId, entryId, options = {}) {
+        return this.httpClient.delete(`${this.basePath}/${taskId}/logbook/${entryId}`, options);
+    }
+    getUserLogbookEntries(limit = 50, offset = 0, options = {}) {
+        return this.httpClient.get(`${this.basePath}/logbook/mine`, {
+            ...options,
+            params: { limit: String(limit), offset: String(offset) },
+        });
+    }
 }
 exports.TaskService = TaskService;