@internetderdinge/api 1.229.0 → 1.229.2

package/dist/src/utils/deviceUtils.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "fs";
+import path from "path";
+let deviceList = null;
+const parseDeviceList = (value) => {
+    if (!Array.isArray(value)) {
+        throw new Error("Device list must be an array.");
+    }
+    return value;
+};
+const loadDeviceListFromFile = (listPath) => {
+    const absolutePath = path.resolve(listPath);
+    const raw = readFileSync(absolutePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parseDeviceList(parsed);
+};
+export const initDeviceList = (options = {}) => {
+    if (options.list) {
+        deviceList = options.list;
+        return deviceList;
+    }
+    if (options.listPath) {
+        deviceList = loadDeviceListFromFile(options.listPath);
+        return deviceList;
+    }
+    throw new Error("initDeviceList requires list or listPath.");
+};
+const ensureDeviceList = () => {
+    if (!deviceList) {
+        throw new Error("deviceList is not initialized. Call initDeviceList(...) before using device utilities.");
+    }
+    return deviceList;
+};
+export { deviceList as default };
+export function deviceByKind(device) {
+    const list = ensureDeviceList();
+    const result = list.find((e) => e.id === device);
+    return result;
+}
+export function deviceByDeviceName(deviceName) {
+    if (!deviceName)
+        return false;
+    const list = ensureDeviceList();
+    const result = list.find((e) => {
+        if (!e.deviceNameDetection)
+            return false;
+        return deviceName.startsWith(e.deviceNameDetection);
+    });
+    if (!result)
+        return false;
+    return result;
+}
+/**
+ * Returns true if the device kind has the given feature
+ */
+export function deviceKindHasFeature(feature, kind) {
+    if (!kind)
+        return false;
+    const list = ensureDeviceList();
+    const result = list.find((e) => e.id === kind);
+    if (!result)
+        return false;
+    return result.features.includes(feature);
+}

package/dist/src/utils/filterOptions.js

@@ -0,0 +1,24 @@
+import mongoose from 'mongoose';
+const { ObjectId } = mongoose.Types;
+const filterOptions = (query, filter, options) => {
+    let filterAlt = filter;
+    if (query.search && mongoose.isValidObjectId(query.search)) {
+        const idList = options.objectIds.map((e) => ({
+            [e]: new ObjectId(query.search),
+        }));
+        filterAlt = {
+            $and: [filter, { $or: idList }],
+        };
+    }
+    else if (query.search) {
+        const regexp = new RegExp(query.search, 'i');
+        const searchList = options.search.map((e) => ({
+            [e]: { $regex: regexp },
+        }));
+        filterAlt = {
+            $and: [filter, { $or: searchList }],
+        };
+    }
+    return filterAlt;
+};
+export { filterOptions };

package/dist/src/utils/medicationName.js

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import i18n from "../i18n/i18n";
+export const medicationName = (entry, lng) => {
+    const name = entry.medicationData?.Kurzname
+        ? entry.medicationData.Kurzname
+        : entry.localMedicationData?.meta?.name
+            ? entry.localMedicationData.meta.name.replace(/ .*/, "")
+            : i18n.t("A medication", { lng });
+    return name;
+};

package/dist/src/utils/pick.js

@@ -0,0 +1,16 @@
+/**
+ * Create an object composed of the picked object properties
+ * @param {Record<string, any>} object - The source object
+ * @param {string[]} keys - The keys to pick
+ * @returns {Partial<Record<string, any>>} - The new object with picked properties
+ */
+// @ts-nocheck
+const pick = (object, keys) => {
+    return keys.reduce((obj, key) => {
+        if (object && Object.prototype.hasOwnProperty.call(object, key)) {
+            obj[key] = object[key];
+        }
+        return obj;
+    }, {});
+};
+export default pick;

package/dist/src/utils/registerOpenApi.js

@@ -0,0 +1,67 @@
+import { OpenAPIRegistry } from "@asteasolutions/zod-to-openapi";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+extendZodWithOpenApi(z);
+export const registry = new OpenAPIRegistry();
+// add Bearer JWT auth
+export const bearerAuth = registry.registerComponent("securitySchemes", "bearerAuth", {
+    type: "http",
+    scheme: "bearer",
+    bearerFormat: "JWT",
+    description: "JWT Bearer authentication",
+});
+export const xApiKey = registry.registerComponent("securitySchemes", "x-api-key", {
+    type: "apiKey",
+    in: "header",
+    name: "x-api-key",
+    description: "API key for authentication",
+});
+const UserSchema = z
+    .object({
+    id: z.string().openapi({ example: "1212121" }),
+    name: z.string().openapi({ example: "John Doe" }),
+    age: z.number().openapi({ example: 42 }),
+})
+    .openapi("User");
+registry.registerPath({
+    method: "get",
+    path: "/usersnnn/{id}",
+    summary: "Get a single user",
+    request: {
+        params: z.object({ id: z.string() }),
+    },
+    responses: {
+        200: {
+            description: "Object with user data.",
+            content: {
+                "application/json": {
+                    schema: UserSchema,
+                },
+            },
+        },
+    },
+});
+registry.registerPath({
+    method: "get",
+    path: "/users/{id}",
+    description: "Get user data by its id",
+    summary: "Get a single user",
+    request: {
+        params: z.object({
+            id: z.string().openapi({ example: "1212121" }),
+        }),
+    },
+    responses: {
+        200: {
+            description: "Object with user data.",
+            content: {
+                "application/json": {
+                    schema: UserSchema,
+                },
+            },
+        },
+        204: {
+            description: "No content - successful operation",
+        },
+    },
+});

package/dist/src/utils/urlUtils.js

@@ -0,0 +1,15 @@
+export const resolvePossiblyRelativeUrl = (maybeUrl, baseUrl) => {
+    if (!maybeUrl)
+        return null;
+    if (maybeUrl.startsWith('http'))
+        return maybeUrl;
+    if (baseUrl && baseUrl.startsWith('http')) {
+        try {
+            return new URL(maybeUrl, baseUrl).toString();
+        }
+        catch {
+            return maybeUrl;
+        }
+    }
+    return maybeUrl;
+};

package/dist/src/utils/userName.js

@@ -0,0 +1,22 @@
+// @ts-nocheck
+import { getUserById } from "../accounts/auth0.service";
+const generateUserName = async (patient) => {
+    if (patient.owner) {
+        const auth0UserById = await getUserById(patient.owner);
+        patient.auth0User = auth0UserById.data;
+    }
+    if (patient?.auth0User?.app_metadata?.first_name) {
+        return `${patient.auth0User.app_metadata.first_name} ${patient.auth0User.app_metadata.last_name}`;
+    }
+    if (patient?.auth0User?.family_name) {
+        return `${patient.auth0User.given_name} ${patient.auth0User.family_name}`;
+    }
+    if (patient && patient?.auth0User) {
+        return patient.auth0User.name;
+    }
+    if (patient && (patient.meta?.firstName || patient.meta?.lastName)) {
+        return `${patient.meta?.firstName}${patient.meta?.firstName ? " " : ""}${patient.meta?.lastName}`;
+    }
+    return null;
+};
+export default generateUserName;

package/dist/src/utils/zValidations.js

@@ -0,0 +1,143 @@
+// @ts-nocheck
+import { z } from "zod";
+import mongoose from "mongoose";
+export const zPagination = {
+    query: z.object({
+        name: z
+            .string()
+            .openapi({
+            example: "John",
+            description: "Name to filter by",
+            param: { name: "name", in: "query" },
+        })
+            .optional(),
+        role: z
+            .string()
+            .openapi({
+            example: "admin",
+            description: "Role to filter by",
+            param: { name: "role", in: "query" },
+        })
+            .optional(),
+        sortBy: z
+            .string()
+            .openapi({
+            example: "createdAt",
+            description: "Field to sort by",
+            param: { name: "sortBy", in: "query" },
+        })
+            .optional(),
+        search: z
+            .string()
+            .openapi({
+            example: process.env.SCHEMA_EXAMPLE_SEARCH || "",
+            description: "Search term to filter results",
+            param: { name: "search", in: "query" },
+        })
+            .optional(),
+        limit: z.coerce
+            .number()
+            .openapi({
+            example: 10,
+            description: "Number of items per page",
+            param: { name: "limit", in: "query" },
+        })
+            .int()
+            .min(1)
+            .max(100000)
+            .optional(),
+        offset: z.coerce
+            .number() // was z.int()
+            .openapi({
+            example: 0,
+            description: "Offset for pagination, used to skip a number of items",
+            param: { name: "offset", in: "query" },
+        })
+            .int()
+            .min(0)
+            .max(100000)
+            .optional(),
+        page: z.coerce
+            .number()
+            .int()
+            .openapi({
+            example: 1,
+            description: "Page number for pagination",
+            param: { name: "page", in: "query" },
+        })
+            .min(1)
+            .max(100000)
+            .optional(),
+    }),
+};
+export const zPaginationResponse = () => z.object({
+    results: z.array(z.unknown()), // Replace with your specific item schema
+    totalResults: z
+        .number()
+        .openapi({ example: 100, description: "Total number of items" }),
+    totalPages: z
+        .number()
+        .openapi({ example: 10, description: "Total number of pages" }),
+    page: z
+        .number()
+        .openapi({ example: 1, description: "Current page number" }),
+    limit: z
+        .number()
+        .openapi({ example: 10, description: "Number of items per page" }),
+});
+const defaultObjectIdExample = "682fd0d7d4a6325d9d45b86d";
+const exampleDefaults = {
+    organization: "682fd0d7d4a6325d9d45b86e",
+    user: defaultObjectIdExample,
+    device: "682fd0d7d4a6325d9d45b86f",
+    paper: "682fd0d7d4a6325d9d45b870",
+};
+const objectIdExampleOverrides = {
+    organizationId: process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID || exampleDefaults.organization,
+    organization: process.env.SCHEMA_EXAMPLE_ORGANIZATION_ID || exampleDefaults.organization,
+    userId: process.env.SCHEMA_EXAMPLE_USER_ID || exampleDefaults.user,
+    deviceId: process.env.SCHEMA_EXAMPLE_DEVICE_ID || exampleDefaults.device,
+    device: process.env.SCHEMA_EXAMPLE_DEVICE_ID || exampleDefaults.device,
+    paperId: process.env.SCHEMA_EXAMPLE_PAPER_ID || exampleDefaults.paper,
+    paper: process.env.SCHEMA_EXAMPLE_PAPER_ID || exampleDefaults.paper,
+    patient: process.env.SCHEMA_EXAMPLE_USER_ID || exampleDefaults.user,
+    accountId: process.env.SCHEMA_EXAMPLE_ACCOUNT_ID,
+    tokenId: process.env.SCHEMA_EXAMPLE_TOKEN_ID,
+};
+export const zObjectIdFor = (paramName) => {
+    const example = paramName ? objectIdExampleOverrides[paramName] : undefined;
+    const exampleValue = example || defaultObjectIdExample;
+    return z
+        .string()
+        .refine((val) => {
+        if (process.env.SCHEMA_STRICT_EXAMPLES === "true" && example) {
+            return val === example;
+        }
+        return mongoose.Types.ObjectId.isValid(val);
+    })
+        .openapi({
+        example: exampleValue,
+        description: "A valid MongoDB ObjectId",
+    });
+};
+export const zGet = (id) => ({
+    params: z.object({
+        [id]: zObjectIdFor(id),
+    }),
+});
+export function zPatchBody(shape, message = "At least one field must be provided for update") {
+    // assume user passed in already-optional vals
+    return z.object(shape); // .refine((o) => Object.keys(o).length > 0, { message });
+}
+export const zUpdate = (id) => ({
+    params: z.object({
+        [id]: zObjectIdFor(id),
+    }),
+});
+export const zDelete = (id) => ({
+    params: z.object({
+        [id]: zObjectIdFor(id),
+    }),
+});
+export const zObjectId = zObjectIdFor();
+export const zDate = () => z.string().pipe(z.coerce.date());

package/dist/src/validations/auth.validation.cjs

@@ -0,0 +1,53 @@
+"use strict";
+const Joi = require('joi');
+const { password } = require('./custom.validation.ts');
+const register = {
+    body: Joi.object().keys({
+        email: Joi.string().required().email(),
+        password: Joi.string().required().custom(password),
+        name: Joi.string().required(),
+    }),
+};
+const login = {
+    body: Joi.object().keys({
+        email: Joi.string().required(),
+        password: Joi.string().required(),
+    }),
+};
+const logout = {
+    body: Joi.object().keys({
+        refreshToken: Joi.string().required(),
+    }),
+};
+const refreshTokens = {
+    body: Joi.object().keys({
+        refreshToken: Joi.string().required(),
+    }),
+};
+const forgotPassword = {
+    body: Joi.object().keys({
+        email: Joi.string().email().required(),
+    }),
+};
+const resetPassword = {
+    query: Joi.object().keys({
+        token: Joi.string().required(),
+    }),
+    body: Joi.object().keys({
+        password: Joi.string().required().custom(password),
+    }),
+};
+const verifyEmail = {
+    query: Joi.object().keys({
+        token: Joi.string().required(),
+    }),
+};
+module.exports = {
+    register,
+    login,
+    logout,
+    refreshTokens,
+    forgotPassword,
+    resetPassword,
+    verifyEmail,
+};

package/dist/src/validations/custom.validation.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+// Can be anything starting with nrf- or epd7, or epd- followed by a number
+export const deviceId = () => z.string().regex(/^(?:nrf-.*|epd7.*|epd-\d+)$/, {
+    message: 'must start with "nrf-", "epd7" or "epd-" followed by a number',
+});
+export const objectId = () => z.string().regex(/^[0-9a-fA-F]{24}$/, {
+    message: 'must be a valid mongo id',
+});
+export const password = () => z
+    .string()
+    .min(8, 'password must be at least 8 characters')
+    .refine((val) => /\d/.test(val) && /[a-zA-Z]/.test(val), {
+    message: 'password must contain at least 1 letter and 1 number',
+});
+export default {
+    deviceId,
+    objectId,
+    password,
+};

package/dist/src/validations/index.cjs

@@ -0,0 +1,3 @@
+"use strict";
+module.exports.authValidation = require('./auth.validation.cjs');
+module.exports.userValidation = require('./user.validation.cjs');