@unchainedshop/core 4.6.1 → 4.7.2

package/lib/services/updateCartItem.js

@@ -0,0 +1,37 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, } from "../errors/index.js";
+export async function updateCartItemService(params, context) {
+    const { itemId, configuration, quantity = 1 } = params;
+    const item = await this.orders.positions.findOrderPosition({ itemId });
+    if (!item) {
+        throw new OrderItemNotFoundError({ orderItemId: itemId });
+    }
+    const order = await this.orders.findOrder({ orderId: item.orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: item.orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const product = await this.products.findProduct({ productId: item.productId });
+    if (!product) {
+        throw new ProductNotFoundError({ productId: item.productId });
+    }
+    if (quantity !== null && quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
+        configuration,
+        quantityDiff: quantity - item.quantity,
+    }, context);
+    await this.orders.positions.updateProductItem({
+        orderPositionId: item._id,
+        quantity: quantity || null,
+        configuration: configuration || null,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({ itemId: item._id }));
+}

package/lib/services/updateEnrollment.d.ts

@@ -0,0 +1,13 @@
+import { type Enrollment, type EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface UpdateEnrollmentParams {
+    enrollmentId: string;
+    contact?: Contact;
+    plan?: EnrollmentPlan;
+    billingAddress?: Address;
+    payment?: Enrollment['payment'];
+    delivery?: Enrollment['delivery'];
+    meta?: any;
+}
+export declare function updateEnrollmentService(this: Modules, params: UpdateEnrollmentParams): Promise<Enrollment>;

package/lib/services/updateEnrollment.js

@@ -0,0 +1,36 @@
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { initializeEnrollmentService } from "./initializeEnrollment.js";
+import { EnrollmentNotFoundError, EnrollmentWrongStatusError, EnrollmentPlanUpdateNotAllowedError, } from "../errors/index.js";
+export async function updateEnrollmentService(params) {
+    const { enrollmentId, billingAddress, contact, delivery, meta, payment, plan } = params;
+    let enrollment = await this.enrollments.findEnrollment({ enrollmentId });
+    if (!enrollment) {
+        throw new EnrollmentNotFoundError({ enrollmentId });
+    }
+    if (enrollment.status === EnrollmentStatus.TERMINATED) {
+        throw new EnrollmentWrongStatusError({ status: enrollment.status, enrollmentId: enrollment._id });
+    }
+    if (meta) {
+        enrollment = (await this.enrollments.updateContext(enrollmentId, meta));
+    }
+    if (billingAddress) {
+        enrollment = (await this.enrollments.updateBillingAddress(enrollmentId, billingAddress));
+    }
+    if (contact) {
+        enrollment = (await this.enrollments.updateContact(enrollmentId, contact));
+    }
+    if (payment) {
+        enrollment = (await this.enrollments.updatePayment(enrollmentId, payment));
+    }
+    if (delivery) {
+        enrollment = (await this.enrollments.updateDelivery(enrollmentId, delivery));
+    }
+    if (plan) {
+        if (enrollment.status !== EnrollmentStatus.INITIAL) {
+            throw new EnrollmentPlanUpdateNotAllowedError({ status: enrollment.status, enrollmentId });
+        }
+        enrollment = (await this.enrollments.updatePlan(enrollmentId, plan));
+        enrollment = await initializeEnrollmentService.bind(this)(enrollment, { reason: 'updated_plan' });
+    }
+    return enrollment;
+}

package/lib/services/uploadFileFromStream.js

@@ -1,4 +1,5 @@
-import { getFileFromFileData, getFileAdapter } from '@unchainedshop/core-files';
+import { getFileFromFileData } from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function uploadFileFromStreamService({ directoryName, rawFile, meta, ...options }) {
     const fileUploadAdapter = getFileAdapter();
     const uploadFileData = await fileUploadAdapter.uploadFileFromStream(directoryName, rawFile, {

package/lib/services/uploadFileFromURL.js

@@ -1,4 +1,5 @@
-import { getFileFromFileData, getFileAdapter } from '@unchainedshop/core-files';
+import { getFileFromFileData } from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function uploadFileFromURLService({ directoryName, fileInput, meta, }) {
     const fileUploadAdapter = getFileAdapter();
     const uploadFileData = await fileUploadAdapter.uploadFileFromURL(directoryName, fileInput, {

package/lib/services/verifyEmailWithMigration.d.ts

@@ -0,0 +1,15 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface VerifyEmailHttpContext {
+    remoteAddress?: string;
+    remotePort?: number;
+    userAgent?: string;
+    locale?: string;
+    countryCode: string;
+}
+export interface VerifyEmailParams {
+    token: string;
+    currentUserId?: string;
+    httpContext: VerifyEmailHttpContext;
+}
+export declare function verifyEmailWithMigrationService(this: Modules, params: VerifyEmailParams): Promise<User>;

package/lib/services/verifyEmailWithMigration.js

@@ -0,0 +1,23 @@
+import { nextUserCartService } from "./nextUserCart.js";
+import { migrateUserDataService } from "./migrateUserData.js";
+import { InvalidEmailVerificationTokenError } from "../errors/index.js";
+export async function verifyEmailWithMigrationService(params) {
+    const { token, currentUserId, httpContext } = params;
+    const unverifiedToken = await this.users.findUnverifiedEmailToken(token);
+    if (!unverifiedToken) {
+        throw new InvalidEmailVerificationTokenError({ token });
+    }
+    await this.users.verifyEmail(unverifiedToken.userId, unverifiedToken.address);
+    const user = (await this.users.updateHeartbeat(unverifiedToken.userId, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    if (currentUserId) {
+        await migrateUserDataService.bind(this)(currentUserId, user._id);
+    }
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/utils/getFileAdapter.d.ts

@@ -0,0 +1 @@
+export declare const getFileAdapter: () => import("@unchainedshop/core-files").IFileAdapter<unknown>;

package/lib/utils/getFileAdapter.js

@@ -0,0 +1,7 @@
+import { FileDirector } from "../directors/FileDirector.js";
+export const getFileAdapter = () => {
+    const adapters = FileDirector.getAdapters();
+    if (adapters.length === 0)
+        throw Error('No file adapter found.');
+    return adapters[0];
+};

package/lib/utils/schedule.js

@@ -99,37 +99,173 @@ function parseText(text) {
             throw new Error(`Unsupported time unit: ${unit}`);
     }
 }
+function findNextInSorted(sorted, minVal) {
+    for (const v of sorted) {
+        if (v >= minVal)
+            return v;
+    }
+    return null;
+}
+function daysInMonth(year, month) {
+    return new Date(year, month, 0).getDate();
+}
 function getNextOccurrences(scheduleData, count, referenceDate) {
     const results = [];
-    const schedule = scheduleData.schedules[0];
-    const current = new Date(referenceDate.getTime());
-    current.setMilliseconds(0);
-    current.setSeconds(current.getSeconds() + 1);
-    const maxIterations = 366 * 24 * 60 * 60;
-    let iterations = 0;
-    while (results.length < count && iterations < maxIterations) {
-        iterations++;
-        const month = current.getMonth() + 1;
-        const dayOfMonth = current.getDate();
-        const dayOfWeek = current.getDay();
-        const hour = current.getHours();
-        const minute = current.getMinutes();
-        const second = current.getSeconds();
-        const matchesMonth = !schedule.M || schedule.M.includes(month);
-        const matchesDay = !schedule.D || schedule.D.includes(dayOfMonth);
-        const matchesDayOfWeek = !schedule.d || schedule.d.includes(dayOfWeek);
-        const matchesHour = !schedule.h || schedule.h.includes(hour);
-        const matchesMinute = !schedule.m || schedule.m.includes(minute);
-        const matchesSecond = !schedule.s || schedule.s.includes(second);
-        if (matchesMonth &&
-            matchesDay &&
-            matchesDayOfWeek &&
-            matchesHour &&
-            matchesMinute &&
-            matchesSecond) {
-            results.push(new Date(current));
+    const sched = scheduleData.schedules[0];
+    const start = new Date(referenceDate.getTime());
+    start.setMilliseconds(0);
+    start.setSeconds(start.getSeconds() + 1);
+    let year = start.getFullYear();
+    let month = start.getMonth() + 1;
+    let day = start.getDate();
+    let hour = start.getHours();
+    let minute = start.getMinutes();
+    let second = start.getSeconds();
+    const maxYear = year + 5;
+    search: while (results.length < count && year <= maxYear) {
+        if (sched.M) {
+            const nextMonth = findNextInSorted(sched.M, month);
+            if (nextMonth === null) {
+                year++;
+                month = sched.M[0];
+                day = sched.D ? sched.D[0] : 1;
+                hour = sched.h ? sched.h[0] : 0;
+                minute = sched.m ? sched.m[0] : 0;
+                second = sched.s ? sched.s[0] : 0;
+                continue search;
+            }
+            if (nextMonth > month) {
+                month = nextMonth;
+                day = sched.D ? sched.D[0] : 1;
+                hour = sched.h ? sched.h[0] : 0;
+                minute = sched.m ? sched.m[0] : 0;
+                second = sched.s ? sched.s[0] : 0;
+            }
+        }
+        const maxDay = daysInMonth(year, month);
+        if (sched.D || sched.d) {
+            let found = false;
+            let candidateDay = day;
+            while (candidateDay <= maxDay) {
+                const matchesD = !sched.D || sched.D.includes(candidateDay);
+                if (matchesD) {
+                    const dow = new Date(year, month - 1, candidateDay).getDay();
+                    const matchesDow = !sched.d || sched.d.includes(dow);
+                    if (matchesDow) {
+                        if (candidateDay > day) {
+                            hour = sched.h ? sched.h[0] : 0;
+                            minute = sched.m ? sched.m[0] : 0;
+                            second = sched.s ? sched.s[0] : 0;
+                        }
+                        day = candidateDay;
+                        found = true;
+                        break;
+                    }
+                }
+                candidateDay++;
+            }
+            if (!found) {
+                month++;
+                if (month > 12) {
+                    year++;
+                    month = sched.M ? sched.M[0] : 1;
+                }
+                else if (sched.M) {
+                    const nextM = findNextInSorted(sched.M, month);
+                    if (nextM === null) {
+                        year++;
+                        month = sched.M[0];
+                    }
+                    else {
+                        month = nextM;
+                    }
+                }
+                day = sched.D ? sched.D[0] : 1;
+                hour = sched.h ? sched.h[0] : 0;
+                minute = sched.m ? sched.m[0] : 0;
+                second = sched.s ? sched.s[0] : 0;
+                continue search;
+            }
+        }
+        else if (day > maxDay) {
+            month++;
+            if (month > 12) {
+                year++;
+                month = sched.M ? sched.M[0] : 1;
+            }
+            else if (sched.M) {
+                const nextM = findNextInSorted(sched.M, month);
+                if (nextM === null) {
+                    year++;
+                    month = sched.M[0];
+                }
+                else {
+                    month = nextM;
+                }
+            }
+            day = 1;
+            hour = sched.h ? sched.h[0] : 0;
+            minute = sched.m ? sched.m[0] : 0;
+            second = sched.s ? sched.s[0] : 0;
+            continue search;
+        }
+        if (hour > 23) {
+            day++;
+            hour = sched.h ? sched.h[0] : 0;
+            minute = sched.m ? sched.m[0] : 0;
+            second = sched.s ? sched.s[0] : 0;
+            continue search;
+        }
+        if (sched.h) {
+            const nextHour = findNextInSorted(sched.h, hour);
+            if (nextHour === null) {
+                day++;
+                hour = sched.h[0];
+                minute = sched.m ? sched.m[0] : 0;
+                second = sched.s ? sched.s[0] : 0;
+                continue search;
+            }
+            if (nextHour > hour) {
+                hour = nextHour;
+                minute = sched.m ? sched.m[0] : 0;
+                second = sched.s ? sched.s[0] : 0;
+            }
+        }
+        if (minute > 59) {
+            hour++;
+            minute = sched.m ? sched.m[0] : 0;
+            second = sched.s ? sched.s[0] : 0;
+            continue search;
+        }
+        if (sched.m) {
+            const nextMinute = findNextInSorted(sched.m, minute);
+            if (nextMinute === null) {
+                hour++;
+                minute = sched.m[0];
+                second = sched.s ? sched.s[0] : 0;
+                continue search;
+            }
+            if (nextMinute > minute) {
+                minute = nextMinute;
+                second = sched.s ? sched.s[0] : 0;
+            }
+        }
+        if (second > 59) {
+            minute++;
+            second = sched.s ? sched.s[0] : 0;
+            continue search;
+        }
+        if (sched.s) {
+            const nextSecond = findNextInSorted(sched.s, second);
+            if (nextSecond === null) {
+                minute++;
+                second = sched.s[0];
+                continue search;
+            }
+            second = nextSecond;
         }
-        current.setSeconds(current.getSeconds() + 1);
+        results.push(new Date(year, month - 1, day, hour, minute, second));
+        second++;
     }
     return results;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core",
   "description": "Core orchestration package for the Unchained Engine with business services and directors",
-  "version": "4.6.1",
+  "version": "4.7.2",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",