dalux-build-api 1.1.5 → 2.0.1

package/src/models/users/index.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/** Mirrors models/users/models.py::User. */
+const UserSchema = z.object({
+  userId: z.string(),
+  userType: z.string(),
+  email: z.string().email(),
+  firstName: z.string().nullish(),
+  lastName: z.string().nullish(),
+});
+
+/** Mirrors models/users/models.py::ProjectUser (User + companyId). */
+const ProjectUserSchema = UserSchema.extend({
+  companyId: z.string().nullish(),
+});
+
+const UsersListResponseSchema = listResponseSchema(ProjectUserSchema);
+/** Single-user response wraps User, not ProjectUser — matches Python. */
+const UserResponseSchema = singleResponseSchema(UserSchema);
+
+module.exports = {
+  UserSchema,
+  ProjectUserSchema,
+  UsersListResponseSchema,
+  UserResponseSchema,
+};

package/src/models/versionSets/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema, singleResponseSchema } = require('../helpers');
+
+/** Mirrors models/version_sets/models.py::VersionSet. */
+const VersionSetSchema = z.object({
+  versionSetId: z.string(),
+  name: z.string(),
+  description: z.string().nullish(),
+  status: z.string().nullish(),
+  fileAreaId: z.string(),
+});
+
+const VersionSetsListResponseSchema = listResponseSchema(VersionSetSchema);
+const VersionSetResponseSchema = singleResponseSchema(VersionSetSchema);
+
+module.exports = {
+  VersionSetSchema,
+  VersionSetsListResponseSchema,
+  VersionSetResponseSchema,
+};

package/src/models/workPackages/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { z } = require('zod');
+const { listResponseSchema } = require('../helpers');
+
+/** Mirrors models/work_packages/models.py::WorkPackage (extra="allow" -> passthrough). */
+const WorkPackageSchema = z.object({
+  workpackageId: z.string().nullish(),
+  companyId: z.string().nullish(),
+  name: z.string().nullish(),
+}).passthrough();
+
+/** No single-item response class in Python. */
+const WorkPackagesListResponseSchema = listResponseSchema(WorkPackageSchema);
+
+module.exports = {
+  WorkPackageSchema,
+  WorkPackagesListResponseSchema,
+};

package/src/next.js

@@ -0,0 +1,89 @@
+'use strict';
+
+function normalizeAllowedMethods(allowedMethods) {
+  const normalized = new Set();
+  if (Array.isArray(allowedMethods)) {
+    for (const method of allowedMethods) normalized.add(method);
+  } else if (allowedMethods && typeof allowedMethods === 'object') {
+    for (const [resource, methods] of Object.entries(allowedMethods)) {
+      for (const method of methods) normalized.add(`${resource}.${method}`);
+    }
+  }
+  if (normalized.size === 0) {
+    throw new Error('allowedMethods must explicitly expose at least one Dalux client method');
+  }
+  return normalized;
+}
+
+function json(body, status = 200) {
+  return Response.json(body, { status });
+}
+
+function errorStatus(error) {
+  if (error?.name === 'AuthenticationError') return 401;
+  if (error?.name === 'NotFoundError') return 404;
+  if (error?.name === 'RateLimitError') return 429;
+  if (error?.name === 'ValidationError') return 422;
+  return 502;
+}
+
+/**
+ * Create a Next.js App Router POST handler for a browser Dalux client.
+ *
+ * @param {object} options
+ * @param {object} options.client A server-side client from createClient().
+ * @param {string[]|Record<string, string[]>} options.allowedMethods Explicit RPC allow-list.
+ * @param {(request: Request) => boolean|Response|Promise<boolean|Response>} [options.authorize]
+ * @returns {(request: Request) => Promise<Response>}
+ */
+function createDaluxRouteHandler({ client, allowedMethods, authorize } = {}) {
+  if (!client || typeof client !== 'object') {
+    throw new Error('A server-side Dalux client is required');
+  }
+  const allowed = normalizeAllowedMethods(allowedMethods);
+
+  return async function POST(request) {
+    if (authorize) {
+      const authorization = await authorize(request);
+      if (authorization instanceof Response) return authorization;
+      if (!authorization) return json({ ok: false, error: { name: 'AuthenticationError', message: 'Unauthorized' } }, 401);
+    }
+
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return json({ ok: false, error: { name: 'ValidationError', message: 'Request body must be JSON' } }, 400);
+    }
+
+    const { resource, method, args = [] } = payload || {};
+    const qualifiedMethod = `${resource}.${method}`;
+    if (!allowed.has(qualifiedMethod)) {
+      return json({ ok: false, error: { name: 'NotFoundError', message: `Method ${qualifiedMethod} is not exposed` } }, 404);
+    }
+    if (!Array.isArray(args)) {
+      return json({ ok: false, error: { name: 'ValidationError', message: 'args must be an array' } }, 400);
+    }
+
+    const target = client[resource];
+    const operation = target?.[method];
+    if (typeof operation !== 'function') {
+      return json({ ok: false, error: { name: 'NotFoundError', message: `Unknown method ${qualifiedMethod}` } }, 404);
+    }
+
+    try {
+      const data = await operation.apply(target, args);
+      return json({ ok: true, data: data === undefined ? null : data });
+    } catch (error) {
+      return json({
+        ok: false,
+        error: {
+          name: error?.name || 'ApiError',
+          message: error?.message || String(error),
+        },
+      }, errorStatus(error));
+    }
+  };
+}
+
+module.exports = { createDaluxRouteHandler };

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Bruno Adam
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.