dalux-build-api 2.2.0 → 2.4.0

package/src/models/index.js

@@ -1,178 +0,0 @@
-'use strict';
-
-/**
- * Zod schemas for Dalux Build API responses. Mirrors the public surface of
- * python/dalux_build/models/__init__.py, with a `Schema` suffix on every
- * export name (these are zod schema objects, not constructible classes).
- */
-
-const { LinkSchema, MetadataSchema } = require('./common');
-
-const {
-  ProjectSchema,
-  ProjectModuleSchema,
-  ProjectMetadataSchema,
-  ProjectTemplateSchema,
-  ProjectCompanySchema,
-  ProjectsListResponseSchema,
-  ProjectResponseSchema,
-} = require('./projects');
-
-const { FileAreaSchema, FileAreasListResponseSchema, FileAreaResponseSchema } = require('./fileAreas');
-
-const { FolderSchema, FoldersListResponseSchema, FolderResponseSchema } = require('./folders');
-
-const {
-  FileSchema,
-  ReferenceSchema,
-  FileNameFilterSchema,
-  FileIntegerPropertySchema,
-  FileDatePropertySchema,
-  FileTextPropertySchema,
-  FileReferencePropertySchema,
-  FilePropertyFieldSchema,
-  FilesListResponseSchema,
-  FileResponseSchema,
-} = require('./files');
-
-const { VersionSetSchema, VersionSetsListResponseSchema, VersionSetResponseSchema } = require('./versionSets');
-
-const { UserSchema, ProjectUserSchema, UsersListResponseSchema, UserResponseSchema } = require('./users');
-
-const { CompaniesListResponseSchema, CompanyResponseSchema } = require('./companies');
-
-const { CompanyCatalogListResponseSchema, CompanyCatalogResponseSchema } = require('./companyCatalog');
-
-const {
-  InspectionPlanSchema,
-  InspectionPlanItemSchema,
-  InspectionPlanItemZoneSchema,
-  InspectionPlanRegistrationSchema,
-  InspectionPlansListResponseSchema,
-  InspectionPlanItemsListResponseSchema,
-  InspectionPlanItemZonesListResponseSchema,
-  InspectionPlanRegistrationsListResponseSchema,
-} = require('./inspectionPlans');
-
-const {
-  TestPlanSchema,
-  TestPlanItemSchema,
-  TestPlanItemZoneSchema,
-  TestPlanRegistrationSchema,
-  TestPlansListResponseSchema,
-  TestPlanItemsListResponseSchema,
-  TestPlanItemZonesListResponseSchema,
-  TestPlanRegistrationsListResponseSchema,
-} = require('./testPlans');
-
-const { FormSchema, FormsListResponseSchema, FormResponseSchema } = require('./forms');
-
-const {
-  TaskSchema,
-  TaskAttachmentSchema,
-  TaskChangeSchema,
-  TaskChangeActorSchema,
-  TaskChangeFieldsSchema,
-  TaskChangeLocationSchema,
-  TaskListParamsSchema,
-  TasksListResponseSchema,
-  TaskResponseSchema,
-  TaskChangeResponseSchema,
-  TaskChangesSchema,
-  TaskAttachmentsListResponseSchema,
-} = require('./tasks');
-
-const { FileRevisionSchema } = require('./fileRevisions');
-const { FileUploadSchema } = require('./fileUpload');
-const { WorkPackageSchema, WorkPackagesListResponseSchema } = require('./workPackages');
-
-module.exports = {
-  // Base
-  LinkSchema,
-  MetadataSchema,
-  // Projects
-  ProjectSchema,
-  ProjectModuleSchema,
-  ProjectMetadataSchema,
-  ProjectTemplateSchema,
-  ProjectCompanySchema,
-  ProjectsListResponseSchema,
-  ProjectResponseSchema,
-  // File Areas
-  FileAreaSchema,
-  FileAreasListResponseSchema,
-  FileAreaResponseSchema,
-  // Folders
-  FolderSchema,
-  FoldersListResponseSchema,
-  FolderResponseSchema,
-  // Files
-  FileSchema,
-  ReferenceSchema,
-  FileNameFilterSchema,
-  FileIntegerPropertySchema,
-  FileDatePropertySchema,
-  FileTextPropertySchema,
-  FileReferencePropertySchema,
-  FilePropertyFieldSchema,
-  FilesListResponseSchema,
-  FileResponseSchema,
-  // Version Sets
-  VersionSetSchema,
-  VersionSetsListResponseSchema,
-  VersionSetResponseSchema,
-  // Users
-  UserSchema,
-  ProjectUserSchema,
-  UsersListResponseSchema,
-  UserResponseSchema,
-  // Companies
-  CompaniesListResponseSchema,
-  CompanyResponseSchema,
-  // Company Catalog
-  CompanyCatalogListResponseSchema,
-  CompanyCatalogResponseSchema,
-  // Inspection Plans
-  InspectionPlanSchema,
-  InspectionPlanItemSchema,
-  InspectionPlanItemZoneSchema,
-  InspectionPlanRegistrationSchema,
-  InspectionPlansListResponseSchema,
-  InspectionPlanItemsListResponseSchema,
-  InspectionPlanItemZonesListResponseSchema,
-  InspectionPlanRegistrationsListResponseSchema,
-  // Test Plans
-  TestPlanSchema,
-  TestPlanItemSchema,
-  TestPlanItemZoneSchema,
-  TestPlanRegistrationSchema,
-  TestPlansListResponseSchema,
-  TestPlanItemsListResponseSchema,
-  TestPlanItemZonesListResponseSchema,
-  TestPlanRegistrationsListResponseSchema,
-  // Forms
-  FormSchema,
-  FormsListResponseSchema,
-  FormResponseSchema,
-  // Tasks
-  TaskSchema,
-  TaskAttachmentSchema,
-  TaskChangeSchema,
-  TaskChangeActorSchema,
-  TaskChangeFieldsSchema,
-  TaskChangeLocationSchema,
-  TaskListParamsSchema,
-  TasksListResponseSchema,
-  TaskResponseSchema,
-  TaskChangeResponseSchema,
-  TaskChangesSchema,
-  TaskAttachmentsListResponseSchema,
-  // Project Templates (same ProjectTemplateSchema as Projects, re-exported above)
-  // File Revisions
-  FileRevisionSchema,
-  // File Upload
-  FileUploadSchema,
-  // Work Packages
-  WorkPackageSchema,
-  WorkPackagesListResponseSchema,
-};

package/src/models/inspectionPlans/index.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const { z } = require('zod');
-const { listResponseSchema } = require('../helpers');
-
-const optionalString = z.string().nullish();
-const optionalInteger = z.number().int().nullish();
-
-const InspectionPlanSchema = z.object({
-  inspectionPlanId: optionalString,
-  name: optionalString,
-  workpackageId: optionalString,
-}).passthrough();
-
-const InspectionPlanItemSchema = z.object({
-  inspectionPlanItemId: optionalString,
-  inspectionPlanId: optionalString,
-  number: optionalString,
-  subject: optionalString,
-  heading: optionalString,
-  subHeading: optionalString,
-  extentType: optionalString,
-  planned: optionalInteger,
-  ongoing: optionalInteger,
-  completed: optionalInteger,
-  nonPlannedOngoing: optionalInteger,
-  nonPlannedCompleted: optionalInteger,
-}).passthrough();
-
-const InspectionPlanItemZoneSchema = z.object({
-  inspectionPlanItemId: optionalString,
-  inspectionPlanItemZoneId: optionalString,
-  name: optionalString,
-  planned: optionalInteger,
-  ongoing: optionalInteger,
-  completed: optionalInteger,
-}).passthrough();
-
-const InspectionPlanRegistrationSchema = z.object({
-  status: optionalString,
-  formId: optionalString,
-  taskId: optionalString,
-  inspectionPlanItemId: optionalString,
-  inspectionPlanItemZoneId: optionalString,
-}).passthrough();
-
-const InspectionPlansListResponseSchema = listResponseSchema(InspectionPlanSchema);
-const InspectionPlanItemsListResponseSchema = listResponseSchema(InspectionPlanItemSchema);
-const InspectionPlanItemZonesListResponseSchema = listResponseSchema(InspectionPlanItemZoneSchema);
-const InspectionPlanRegistrationsListResponseSchema = listResponseSchema(InspectionPlanRegistrationSchema);
-
-module.exports = {
-  InspectionPlanSchema,
-  InspectionPlanItemSchema,
-  InspectionPlanItemZoneSchema,
-  InspectionPlanRegistrationSchema,
-  InspectionPlansListResponseSchema,
-  InspectionPlanItemsListResponseSchema,
-  InspectionPlanItemZonesListResponseSchema,
-  InspectionPlanRegistrationsListResponseSchema,
-};

package/src/models/projectTemplates/index.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const { ProjectTemplateSchema } = require('../projects');
-
-/**
- * Mirrors models/project_templates/models.py::ProjectTemplate — identical
- * shape to projects/models.py::ProjectTemplate, so it's reused rather than
- * duplicated. listProjectTemplates returns raw/unmodeled data in Python too
- * (company-wide endpoint), so no response wrapper is defined here.
- */
-module.exports = { ProjectTemplateSchema };

package/src/models/projects/index.js

@@ -1,57 +0,0 @@
-'use strict';
-
-const { z } = require('zod');
-const { listResponseSchema, singleResponseSchema } = require('../helpers');
-
-/** Mirrors models/projects/models.py::ProjectModule (empty placeholder, passthrough). */
-const ProjectModuleSchema = z.object({}).passthrough();
-
-/** Mirrors models/projects/models.py::Project. Note: `type` is the real JSON key (Python aliases project_type -> "type"). */
-const ProjectSchema = z.object({
-  projectId: z.string(),
-  projectName: z.string(),
-  type: z.string().nullish(),
-  projectTemplateId: z.string().nullish(),
-  address: z.string().nullish(),
-  number: z.string().nullish(),
-  created: z.string().nullish(),
-  closing: z.string().nullish(),
-  modules: z.array(ProjectModuleSchema).nullish(),
-});
-
-/** Mirrors models/projects/models.py::ProjectMetadata. */
-const ProjectMetadataSchema = z.object({
-  key: z.string(),
-  value: z.string().nullish(),
-});
-
-/** Mirrors models/projects/models.py::ProjectTemplate (also duplicated in project_templates/models.py — same shape). */
-const ProjectTemplateSchema = z.object({
-  projectTemplateId: z.string(),
-  name: z.string(),
-});
-
-/** Mirrors models/projects/models.py::ProjectCompany. */
-const ProjectCompanySchema = z.object({
-  companyId: z.string().nullish(),
-  name: z.string().nullish(),
-  vatNumber: z.string().nullish(),
-  address: z.string().nullish(),
-  city: z.string().nullish(),
-  postalCode: z.string().nullish(),
-  country: z.string().nullish(),
-  catalogCompanyId: z.string().nullish(),
-});
-
-const ProjectsListResponseSchema = listResponseSchema(ProjectSchema);
-const ProjectResponseSchema = singleResponseSchema(ProjectSchema);
-
-module.exports = {
-  ProjectModuleSchema,
-  ProjectSchema,
-  ProjectMetadataSchema,
-  ProjectTemplateSchema,
-  ProjectCompanySchema,
-  ProjectsListResponseSchema,
-  ProjectResponseSchema,
-};

package/src/models/tasks/index.js

@@ -1,105 +0,0 @@
-'use strict';
-
-const { z } = require('zod');
-const { listResponseSchema, singleResponseSchema } = require('../helpers');
-
-/** Mirrors models/tasks/models.py::Task (extra="allow" -> passthrough; only taskId is typed). */
-const TaskSchema = z.object({
-  taskId: z.string().nullish(),
-}).passthrough();
-
-/**
- * Mirrors models/tasks/models.py::TaskListParams. Field names are the
- * actual OData query keys (matches what src/api/TasksApi.js's
- * normalizeTaskParams reads/writes) rather than Python's snake_case
- * attribute names, since JS has no alias layer to bridge the two. These are
- * developer-supplied query params (not API responses), so plain `.optional()`
- * is fine.
- */
-const TaskListParamsSchema = z.object({
-  typeId: z.string().optional(),
-  $filter: z.string().optional(),
-  $select: z.string().optional(),
-  $orderby: z.string().optional(),
-  $top: z.number().optional(),
-  $skip: z.number().optional(),
-  bookmark: z.string().optional(),
-}).passthrough();
-
-/** Mirrors models/tasks/models.py::TaskChangeActor. */
-const TaskChangeActorSchema = z.object({
-  userId: z.string().nullish(),
-  roleId: z.string().nullish(),
-  roleName: z.string().nullish(),
-  userName: z.string().nullish(),
-  name: z.string().nullish(),
-}).passthrough();
-
-/** Mirrors models/tasks/models.py::TaskChangeLocation (empty passthrough). */
-const TaskChangeLocationSchema = z.object({}).passthrough();
-
-/**
- * Preprocesses the deadline field the same way Python's
- * `normalize_deadline` field_validator does: unwraps API payloads where
- * deadline is returned as an object instead of a bare string.
- */
-const deadlineSchema = z.preprocess((value) => {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    if (value.empty === true) return undefined;
-    if ('value' in value) return value.value;
-    if ('date' in value) return value.date;
-    if ('datetime' in value) return value.datetime;
-  }
-  return value;
-}, z.string().nullish());
-
-/** Mirrors models/tasks/models.py::TaskChangeFields. */
-const TaskChangeFieldsSchema = z.object({
-  currentResponsible: TaskChangeActorSchema.nullish(),
-  assignedTo: TaskChangeActorSchema.nullish(),
-  title: z.string().nullish(),
-  deadline: deadlineSchema,
-  status: z.string().nullish(),
-  modifiedBy: TaskChangeActorSchema.nullish(),
-  userDefinedFields: z.record(z.any()).nullish(),
-  workpackageId: z.string().nullish(),
-  location: TaskChangeLocationSchema.nullish(),
-}).passthrough();
-
-/** Mirrors models/tasks/models.py::TaskChange. */
-const TaskChangeSchema = z.object({
-  taskId: z.string(),
-  description: z.string().nullish(),
-  timestamp: z.string(),
-  action: z.string(),
-  fields: TaskChangeFieldsSchema.nullish(),
-});
-
-/** Mirrors models/tasks/models.py::TaskAttachment. */
-const TaskAttachmentSchema = z.object({
-  attachmentId: z.string().nullish(),
-  taskId: z.string().nullish(),
-  fileId: z.string().nullish(),
-}).passthrough();
-
-const TasksListResponseSchema = listResponseSchema(TaskSchema);
-const TaskResponseSchema = singleResponseSchema(TaskSchema);
-const TaskChangeResponseSchema = singleResponseSchema(TaskChangeSchema);
-/** Bare-list payloads (`[...]` instead of `{items: [...]}`) are handled by listResponseSchema's preprocessor. */
-const TaskChangesSchema = listResponseSchema(TaskChangeSchema);
-const TaskAttachmentsListResponseSchema = listResponseSchema(TaskAttachmentSchema);
-
-module.exports = {
-  TaskSchema,
-  TaskListParamsSchema,
-  TaskChangeActorSchema,
-  TaskChangeLocationSchema,
-  TaskChangeFieldsSchema,
-  TaskChangeSchema,
-  TaskAttachmentSchema,
-  TasksListResponseSchema,
-  TaskResponseSchema,
-  TaskChangeResponseSchema,
-  TaskChangesSchema,
-  TaskAttachmentsListResponseSchema,
-};

package/src/models/testPlans/index.js

@@ -1,61 +0,0 @@
-'use strict';
-
-const { z } = require('zod');
-const { listResponseSchema } = require('../helpers');
-
-const optionalString = z.string().nullish();
-const optionalInteger = z.number().int().nullish();
-
-const TestPlanSchema = z.object({
-  testPlanId: optionalString,
-  name: optionalString,
-  workpackageId: optionalString,
-}).passthrough();
-
-const TestPlanItemSchema = z.object({
-  testPlanItemId: optionalString,
-  testPlanId: optionalString,
-  number: optionalString,
-  subject: optionalString,
-  heading: optionalString,
-  subHeading: optionalString,
-  extentType: optionalString,
-  planned: optionalInteger,
-  ongoing: optionalInteger,
-  completed: optionalInteger,
-  nonPlannedOngoing: optionalInteger,
-  nonPlannedCompleted: optionalInteger,
-}).passthrough();
-
-const TestPlanItemZoneSchema = z.object({
-  testPlanItemId: optionalString,
-  testPlanItemZoneId: optionalString,
-  name: optionalString,
-  planned: optionalInteger,
-  ongoing: optionalInteger,
-  completed: optionalInteger,
-}).passthrough();
-
-const TestPlanRegistrationSchema = z.object({
-  status: optionalString,
-  formId: optionalString,
-  taskId: optionalString,
-  testPlanItemId: optionalString,
-  testPlanItemZoneId: optionalString,
-}).passthrough();
-
-const TestPlansListResponseSchema = listResponseSchema(TestPlanSchema);
-const TestPlanItemsListResponseSchema = listResponseSchema(TestPlanItemSchema);
-const TestPlanItemZonesListResponseSchema = listResponseSchema(TestPlanItemZoneSchema);
-const TestPlanRegistrationsListResponseSchema = listResponseSchema(TestPlanRegistrationSchema);
-
-module.exports = {
-  TestPlanSchema,
-  TestPlanItemSchema,
-  TestPlanItemZoneSchema,
-  TestPlanRegistrationSchema,
-  TestPlansListResponseSchema,
-  TestPlanItemsListResponseSchema,
-  TestPlanItemZonesListResponseSchema,
-  TestPlanRegistrationsListResponseSchema,
-};

package/src/models/users/index.js

@@ -1,29 +0,0 @@
-'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

@@ -1,22 +0,0 @@
-'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

@@ -1,19 +0,0 @@
-'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

@@ -1,89 +0,0 @@
-'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/src/utils/errors.js

@@ -1,45 +0,0 @@
-'use strict';
-
-/**
- * Base exception for all Dalux API errors.
- */
-class DaluxError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-/**
- * Resource not found (HTTP 404).
- */
-class NotFoundError extends DaluxError {}
-
-/**
- * API request failed (4xx / 5xx other than 401, 404, 429).
- */
-class ApiError extends DaluxError {}
-
-/**
- * Input validation failed.
- */
-class ValidationError extends DaluxError {}
-
-/**
- * Authentication failed (HTTP 401).
- */
-class AuthenticationError extends DaluxError {}
-
-/**
- * Rate limit exceeded (HTTP 429).
- */
-class RateLimitError extends DaluxError {}
-
-module.exports = {
-  DaluxError,
-  NotFoundError,
-  ApiError,
-  ValidationError,
-  AuthenticationError,
-  RateLimitError,
-};