@mittwald/cli 1.2.5 → 1.2.6

package/dist/lib/resources/app/flags.js

@@ -159,7 +159,7 @@ export function provideSupportedFlags(requestedFlagNames, appName) {
     return flagsToReturn;
 }
 export async function autofillFlags(apiClient, process, necessaryFlags, flags, projectId, appName, defaults) {
-    const ownUser = await apiClient.user.getOwnAccount();
+    const ownUser = await apiClient.user.getUser({ userId: "self" });
     assertStatus(ownUser, 200);
     // Version
     if (necessaryFlags.includes("version") && !flags.version) {

package/dist/lib/resources/database/common.js

@@ -1,7 +1,7 @@
 import { assertStatus } from "@mittwald/api-client-commons";
 export async function getUser(apiClient, p) {
     return await p.runStep("fetching user", async () => {
-        const r = await apiClient.user.getOwnAccount();
+        const r = await apiClient.user.getUser({ userId: "self" });
         assertStatus(r, 200);
         return r.data;
     });

package/dist/lib/resources/login/useOwnAccount.d.ts

@@ -1,11 +1,24 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 export default function useOwnAccount(client: MittwaldAPIV2Client): {
+    avatarRef?: string | undefined;
+    customerMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserCustomerMembership;
+    } | undefined;
     email?: string | undefined;
-    mfaDetails?: {
-        mfaConfirmed?: boolean;
-        mfaInitialized?: boolean;
+    employeeInformation?: {
+        department: string;
+    } | undefined;
+    isEmployee?: boolean | undefined;
+    mfa?: {
+        active: boolean;
+        setup: boolean;
     } | undefined;
     passwordUpdatedAt?: string | undefined;
-    person?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson | undefined;
-    userId?: string | undefined;
+    person: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson;
+    phoneNumber?: string | undefined;
+    projectMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserProjectMembership;
+    } | undefined;
+    registeredAt?: string | undefined;
+    userId: string;
 };

package/dist/lib/resources/login/useOwnAccount.js

@@ -1,7 +1,7 @@
 import { assertStatus } from "@mittwald/api-client";
 import { usePromise } from "@mittwald/react-use-promise";
 export default function useOwnAccount(client) {
-    const result = usePromise(() => client.user.getOwnAccount(), []);
+    const result = usePromise(() => client.user.getUser({ userId: "self" }), []);
     assertStatus(result, 200);
     return result.data;
 }

package/dist/lib/resources/ssh/appinstall.js

@@ -13,7 +13,7 @@ export async function getSSHConnectionForAppInstallation(client, appInstallation
     });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/resources/ssh/project.js

@@ -3,7 +3,7 @@ export async function getSSHConnectionForProject(client, projectId, sshUser) {
     const projectResponse = await client.project.getProject({ projectId });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/units/Duration.test.d.ts

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

package/dist/lib/units/Duration.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "@jest/globals";
+import Duration from "./Duration.js";
+describe("Duration class", () => {
+    describe("Static factory methods", () => {
+        test("fromZero should return a Duration of 0 milliseconds", () => {
+            const duration = Duration.fromZero();
+            expect(duration.milliseconds).toBe(0);
+        });
+        test("fromMilliseconds should return a Duration with the given milliseconds", () => {
+            const duration = Duration.fromMilliseconds(500);
+            expect(duration.milliseconds).toBe(500);
+        });
+        test("fromSeconds should return a Duration with the given seconds converted to milliseconds", () => {
+            const duration = Duration.fromSeconds(2);
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should parse valid duration strings", () => {
+            const duration = Duration.fromString("2s");
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should throw an error for invalid input", () => {
+            expect(() => Duration.fromString("invalid")).toThrow("could not parse duration: invalid");
+        });
+    });
+    describe("Instance methods", () => {
+        test("seconds should return duration in seconds", () => {
+            const duration = Duration.fromMilliseconds(3000);
+            expect(duration.seconds).toBe(3);
+        });
+        test("from should return a Date object offset by the duration", () => {
+            const baseDate = new Date("2023-01-01T00:00:00Z");
+            const duration = Duration.fromSeconds(10);
+            expect(duration.from(baseDate)).toEqual(new Date("2023-01-01T00:00:10Z"));
+        });
+        test("fromNow should return a future Date object", () => {
+            const duration = Duration.fromSeconds(5);
+            const now = new Date();
+            const future = duration.fromNow();
+            expect(future.getTime()).toBeGreaterThan(now.getTime());
+        });
+        test("add should correctly add two durations", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            const result = duration1.add(duration2);
+            expect(result.milliseconds).toBe(15000);
+        });
+        test("compare should return correct comparison results", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            expect(duration1.compare(duration2)).toBeGreaterThan(0);
+            expect(duration2.compare(duration1)).toBeLessThan(0);
+            expect(duration1.compare(duration1)).toBe(0);
+        });
+        test("toString should return formatted duration string", () => {
+            expect(Duration.fromMilliseconds(500).toString()).toBe("500ms");
+            expect(Duration.fromSeconds(3).toString()).toBe("3s");
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {
@@ -59,7 +59,7 @@
     "marked": "^12.0.0",
     "marked-terminal": "^6.0.0",
     "open": "^10.0.3",
-    "parse-duration": "^1.1.0",
+    "parse-duration": "^2.0.1",
     "pretty-bytes": "^6.1.0",
     "react": "^18.2.0",
     "semver": "^7.5.4",