@internetderdinge/api 1.229.28 → 1.229.32

package/dist/src/admin/adminSearch.validation.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const adminSearchSchema = {
+    query: z.object({
+        search: z.string().max(120).optional(),
+        limit: z.coerce.number().min(1).max(50).optional(),
+    }),
+};
+export const adminStatsSchema = {
+    query: z.object({}),
+};
+export const adminIotDevicesSchema = {
+    query: z.object({
+        page: z.coerce.number().int().min(1).optional(),
+        perPage: z.coerce.number().int().min(1).max(500).optional(),
+        updatedSince: z.string().datetime().optional(),
+    }),
+};
+export const adminDevicesSchema = {
+    query: z.object({
+        page: z.coerce.number().int().min(1).optional(),
+        perPage: z.coerce.number().int().min(1).max(500).optional(),
+        updatedSince: z.string().datetime().optional(),
+    }),
+};

package/dist/src/index.js

@@ -10,6 +10,7 @@ export { default as i18n } from "../src/i18n/i18n";
 export { default as usersRoute } from "../src/users/users.route";
 export { default as usersService } from "../src/users/users.service";
 export { default as accountsRoute } from "../src/accounts/accounts.route";
+export { default as adminSearchRoute } from "../src/admin/adminSearch.route";
 export { default as accountsService } from "../src/accounts/accounts.service";
 export { auth0 } from "../src/accounts/auth0.service";
 export { default as organizationsRoute } from "../src/organizations/organizations.route";

package/dist/src/utils/registerOpenApi.js

@@ -24,27 +24,6 @@ const UserSchema = z
 })
     .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}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@internetderdinge/api",
-  "version": "1.229.28",
+  "version": "1.229.32",
   "description": "Shared OpenIoT API modules",
   "main": "dist/src/index.js",
   "type": "module",

package/scripts/release-and-sync-paperless.mjs

@@ -2,10 +2,12 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { execSync } from "node:child_process";
+import dotenv from "dotenv";
 import semver from "semver";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, "..");
+dotenv.config({ path: path.join(repoRoot, ".env") });
 
 const args = process.argv.slice(2);
 const shouldPublish = !args.includes("--no-publish");
@@ -44,12 +46,23 @@ const resolveNextVersion = (current, input) => {
   );
 };
 
-const resolvePaperlesspaperWebRoot = () => {
-  if (process.env.PAPERLESSPAPER_WEB_PATH) {
-    return path.resolve(process.env.PAPERLESSPAPER_WEB_PATH);
+const resolveUpdatePackagePaths = () => {
+  const updatePaths = process.env.UPDATE_PATHS?.split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+  if (!updatePaths?.length) {
+    throw new Error(
+      "UPDATE_PATHS must be set in .env to a comma-separated list of package.json paths.",
+    );
   }
 
-  return path.resolve(repoRoot, "../../paperlesspaper-web");
+  return updatePaths.map((updatePath) => {
+    const resolvedPath = path.resolve(repoRoot, updatePath);
+    return path.basename(resolvedPath) === "package.json"
+      ? resolvedPath
+      : path.join(resolvedPath, "package.json");
+  });
 };
 
 const updateDependencyVersion = (
@@ -88,8 +101,9 @@ const updateDependencyVersion = (
     currentDependencyVersion &&
     currentDependencyVersion !== expectedVersion
   ) {
+    const packageName = path.basename(path.dirname(packageJsonPath));
     throw new Error(
-      `paperlesspaper-api dependency is ${currentRange} (expected ${expectedVersion}). Update it before bumping.`,
+      `${packageName} dependency is ${currentRange} (expected ${expectedVersion}). Update it before bumping.`,
     );
   }
 
@@ -117,34 +131,33 @@ if (!cleanedCurrent) {
 }
 
 const nextVersion = resolveNextVersion(currentVersion, versionInput);
+const updatePackagePaths = resolveUpdatePackagePaths();
+
+for (const updatePackagePath of updatePackagePaths) {
+  if (!fs.existsSync(updatePackagePath)) {
+    throw new Error(`Could not find package.json: ${updatePackagePath}`);
+  }
+}
 
 apiPackage.version = nextVersion;
 writeJson(apiPackagePath, apiPackage);
 
 if (shouldPublish) {
+  // Always publish through npm, regardless of the package manager used to run this script.
   execSync("npm publish", { cwd: repoRoot, stdio: "inherit" });
 }
 
-const paperlesspaperRoot = resolvePaperlesspaperWebRoot();
-const paperlessApiPath = path.join(
-  paperlesspaperRoot,
-  "packages/paperlesspaper-api/package.json",
-);
-
-if (!fs.existsSync(paperlessApiPath)) {
-  throw new Error(
-    "Could not find paperlesspaper-api package.json. Set PAPERLESSPAPER_WEB_PATH to the repo root.",
-  );
-}
-
-const paperlessUpdate = updateDependencyVersion(
-  paperlessApiPath,
-  "@internetderdinge/api",
-  nextVersion,
-  cleanedCurrent,
-);
+const updates = updatePackagePaths.map((updatePackagePath) => ({
+  packageName: readJson(updatePackagePath).name,
+  ...updateDependencyVersion(
+    updatePackagePath,
+    "@internetderdinge/api",
+    nextVersion,
+    cleanedCurrent,
+  ),
+}));
 
 console.log(`Updated @internetderdinge/api to ${nextVersion}`);
-console.log(
-  `paperlesspaper-api: ${paperlessUpdate.previous} -> ${paperlessUpdate.next}`,
-);
+for (const update of updates) {
+  console.log(`${update.packageName}: ${update.previous} -> ${update.next}`);
+}

package/src/admin/adminSearch.controller.ts

@@ -0,0 +1,101 @@
+import type { Request, Response } from "express";
+import httpStatus from "http-status";
+import { ApiError } from "../utils/ApiError.js";
+import catchAsync from "../utils/catchAsync.js";
+import {
+  getAdminDevices,
+  getAdminIotDevices,
+  getAdminStats,
+  searchAdminCollections,
+} from "./adminSearch.service.js";
+
+const ADMIN_ROLE_CLAIM = "https://memo.wirewire.de/roles";
+
+type AuthRequest = Request & {
+  auth?: Record<string, unknown>;
+};
+
+const hasAdminRole = (auth: Record<string, unknown> | undefined): boolean => {
+  const roles = auth?.[ADMIN_ROLE_CLAIM];
+  return Array.isArray(roles) && roles.includes("admin");
+};
+
+const readListQuery = (
+  req: Request,
+): {
+  page: number;
+  perPage: number;
+  updatedSince: string | null;
+} => {
+  const rawPage = Number(req.query.page);
+  const rawPerPage = Number(req.query.perPage);
+  const updatedSince = String(req.query.updatedSince ?? "").trim() || null;
+
+  return {
+    page: Number.isFinite(rawPage) ? Math.max(1, Math.floor(rawPage)) : 1,
+    perPage: Number.isFinite(rawPerPage)
+      ? Math.max(1, Math.min(500, Math.floor(rawPerPage)))
+      : 100,
+    updatedSince,
+  };
+};
+
+export const searchAdmin = catchAsync(
+  async (req: AuthRequest, res: Response) => {
+    if (!hasAdminRole(req.auth)) {
+      throw new ApiError(
+        httpStatus.FORBIDDEN,
+        "User is not part of the admin group",
+      );
+    }
+
+    const search = String(req.query.search || "").trim();
+    const rawLimit = Number(req.query.limit);
+    const limit = Number.isFinite(rawLimit)
+      ? Math.max(1, Math.min(50, Math.floor(rawLimit)))
+      : 12;
+
+    const result = await searchAdminCollections({ search, limit });
+    res.send(result);
+  },
+);
+
+export const getStats = catchAsync(async (req: AuthRequest, res: Response) => {
+  if (!hasAdminRole(req.auth)) {
+    throw new ApiError(
+      httpStatus.FORBIDDEN,
+      "User is not part of the admin group",
+    );
+  }
+
+  const result = await getAdminStats();
+  res.send(result);
+});
+
+export const getIotDevices = catchAsync(
+  async (req: AuthRequest, res: Response) => {
+    if (!hasAdminRole(req.auth)) {
+      throw new ApiError(
+        httpStatus.FORBIDDEN,
+        "User is not part of the admin group",
+      );
+    }
+
+    const result = await getAdminIotDevices(readListQuery(req));
+    res.send(result);
+  },
+);
+
+export const getDevices = catchAsync(
+  async (req: AuthRequest, res: Response) => {
+    if (!hasAdminRole(req.auth)) {
+      throw new ApiError(
+        httpStatus.FORBIDDEN,
+        "User is not part of the admin group",
+      );
+    }
+
+    const result = await getAdminDevices(readListQuery(req));
+    res.send(result);
+  },
+);

package/src/admin/adminSearch.route.ts

@@ -0,0 +1,73 @@
+import { Router } from "express";
+import buildRouterAndDocs, { type RouteSpec } from "../utils/buildRouterAndDocs.js";
+import auth from "../middlewares/auth.js";
+import { validateAdmin } from "../middlewares/validateAdmin.js";
+import {
+  getDevices,
+  getIotDevices,
+  getStats,
+  searchAdmin,
+} from "./adminSearch.controller.js";
+import {
+  adminDevicesSchema,
+  adminIotDevicesSchema,
+  adminSearchSchema,
+  adminStatsSchema,
+} from "./adminSearch.validation.js";
+import {
+  adminDevicesResponseSchema,
+  adminIotDevicesResponseSchema,
+  adminSearchResponseSchema,
+  adminStatsResponseSchema,
+} from "./adminSearch.schemas.js";
+
+export const adminSearchRouteSpecs: RouteSpec[] = [
+  {
+    method: "get",
+    path: "/stats",
+    validate: [auth("getUsers"), validateAdmin],
+    requestSchema: adminStatsSchema,
+    responseSchema: adminStatsResponseSchema,
+    handler: getStats,
+    summary: "Get admin stats",
+    description: "Returns total counts for organizations, users, and devices.",
+  },
+  {
+    method: "get",
+    path: "/search",
+    validate: [auth("getUsers"), validateAdmin],
+    requestSchema: adminSearchSchema,
+    responseSchema: adminSearchResponseSchema,
+    handler: searchAdmin,
+    summary: "Search organizations, users, and devices",
+    description:
+      "Performs an admin-only global search over organizations, users, and devices.",
+  },
+  {
+    method: "get",
+    path: "/iotDevices",
+    validate: [auth("getUsers"), validateAdmin],
+    requestSchema: adminIotDevicesSchema,
+    responseSchema: adminIotDevicesResponseSchema,
+    handler: getIotDevices,
+    summary: "List IoT devices",
+    description:
+      "Returns the IoT device status list used for admin device/order sync workflows.",
+  },
+  {
+    method: "get",
+    path: "/devices",
+    validate: [auth("getUsers"), validateAdmin],
+    requestSchema: adminDevicesSchema,
+    responseSchema: adminDevicesResponseSchema,
+    handler: getDevices,
+    summary: "List MongoDB devices",
+    description:
+      "Returns all device documents from MongoDB for admin sync workflows.",
+  },
+];
+
+const router: Router = Router();
+buildRouterAndDocs(router, adminSearchRouteSpecs, "/admin", ["Admin"]);
+
+export default router;

package/src/admin/adminSearch.schemas.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+
+const organizationSearchEntrySchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  kind: z.string().optional(),
+});
+
+const userSearchEntrySchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  email: z.string().optional(),
+  role: z.string().optional(),
+  organization: organizationSearchEntrySchema.optional(),
+});
+
+const deviceSearchEntrySchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  deviceId: z.string().optional(),
+  kind: z.string().optional(),
+  timezone: z.string().optional(),
+  eventDate: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+  serialNumber: z.string().optional(),
+  paymentId: z.string().optional(),
+  batteryStatus: z.string().optional(),
+  batteryLevel: z.number().optional(),
+  signalStrength: z.number().optional(),
+  lastReachableAgo: z.string().optional(),
+  organization: organizationSearchEntrySchema.optional(),
+  patient: z
+    .object({
+      id: z.string(),
+      name: z.string().optional(),
+    })
+    .optional(),
+});
+
+export const adminSearchResponseSchema = z.object({
+  query: z.string(),
+  organizations: z.array(organizationSearchEntrySchema),
+  users: z.array(userSearchEntrySchema),
+  devices: z.array(deviceSearchEntrySchema),
+  total: z.number(),
+  tookMs: z.number(),
+});
+
+export const adminStatsResponseSchema = z.object({
+  users: z.number(),
+  auth0Users: z.number(),
+  devices: z.number(),
+  organizations: z.number(),
+  total: z.number(),
+  tookMs: z.number(),
+});
+
+export const adminIotDevicesResponseSchema = z.object({
+  results: z.array(z.record(z.string(), z.unknown())),
+  page: z.number(),
+  perPage: z.number(),
+  totalPages: z.number(),
+  total: z.number(),
+  tookMs: z.number(),
+});
+
+export const adminDevicesResponseSchema = z.object({
+  results: z.array(z.record(z.string(), z.unknown())),
+  page: z.number(),
+  perPage: z.number(),
+  totalPages: z.number(),
+  total: z.number(),
+  tookMs: z.number(),
+});