@fonderie/workspaces 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { EventBus } from '@fonderie/events';
 import { IInvitation, IMember, IRole, IWorkspaceSettings, IWorkspace } from './types.js';
 export { InvitationStatus, WorkspaceType } from './types.js';
 export { requireWorkspace, withWorkspace } from './middlewares/index.js';
+import { z } from 'zod';
 
 declare const MESSAGE_KEYS: {
     readonly workspaceInvitation: "workspace-invitation";
@@ -95,4 +96,76 @@ declare function toMemberDTO(m: IMember): IMemberDTO;
 declare function toInvitationDTO(inv: IInvitation): IInvitationDTO;
 declare function toSettingsDTO(s: IWorkspaceSettings): IWorkspaceSettingsDTO;
 
-export { EVENT_KEYS, IInvitation, type IInvitationDTO, IMember, type IMemberDTO, IRole, type IRoleDTO, IWorkspace, type IWorkspaceDTO, IWorkspaceSettings, type IWorkspaceSettingsDTO, type IWorkspacesConfig, MESSAGE_KEYS, type WorkspacesEventKey, type WorkspacesMessageKey, WorkspacesModule, toInvitationDTO, toMemberDTO, toRoleDTO, toSettingsDTO, toWorkspaceDTO };
+declare const createWorkspaceSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const updateWorkspaceSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    motto: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    businessType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    address: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        line1: z.ZodOptional<z.ZodString>;
+        line2: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        postalCode: z.ZodOptional<z.ZodString>;
+        country: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$strip>;
+declare const updateSettingsSchema: z.ZodObject<{
+    locale: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    currency: z.ZodOptional<z.ZodString>;
+    dateFormat: z.ZodOptional<z.ZodString>;
+    timeFormat: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const addMemberRoleSchema: z.ZodObject<{
+    roleId: z.ZodString;
+}, z.core.$strip>;
+declare const createInvitationsSchema: z.ZodUnion<readonly [z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    roleId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    roleId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>]>;
+declare const acceptInvitationSchema: z.ZodObject<{
+    pin: z.ZodString;
+}, z.core.$strip>;
+declare const createRoleSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const updateRoleSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    active: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const setRolePermissionsSchema: z.ZodObject<{
+    permissions: z.ZodArray<z.ZodObject<{
+        permissionKey: z.ZodString;
+        canCreate: z.ZodOptional<z.ZodBoolean>;
+        canRead: z.ZodOptional<z.ZodBoolean>;
+        canUpdate: z.ZodOptional<z.ZodBoolean>;
+        canDelete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare const schemas_acceptInvitationSchema: typeof acceptInvitationSchema;
+declare const schemas_addMemberRoleSchema: typeof addMemberRoleSchema;
+declare const schemas_createInvitationsSchema: typeof createInvitationsSchema;
+declare const schemas_createRoleSchema: typeof createRoleSchema;
+declare const schemas_createWorkspaceSchema: typeof createWorkspaceSchema;
+declare const schemas_setRolePermissionsSchema: typeof setRolePermissionsSchema;
+declare const schemas_updateRoleSchema: typeof updateRoleSchema;
+declare const schemas_updateSettingsSchema: typeof updateSettingsSchema;
+declare const schemas_updateWorkspaceSchema: typeof updateWorkspaceSchema;
+declare namespace schemas {
+  export { schemas_acceptInvitationSchema as acceptInvitationSchema, schemas_addMemberRoleSchema as addMemberRoleSchema, schemas_createInvitationsSchema as createInvitationsSchema, schemas_createRoleSchema as createRoleSchema, schemas_createWorkspaceSchema as createWorkspaceSchema, schemas_setRolePermissionsSchema as setRolePermissionsSchema, schemas_updateRoleSchema as updateRoleSchema, schemas_updateSettingsSchema as updateSettingsSchema, schemas_updateWorkspaceSchema as updateWorkspaceSchema };
+}
+
+export { EVENT_KEYS, IInvitation, type IInvitationDTO, IMember, type IMemberDTO, IRole, type IRoleDTO, IWorkspace, type IWorkspaceDTO, IWorkspaceSettings, type IWorkspaceSettingsDTO, type IWorkspacesConfig, MESSAGE_KEYS, type WorkspacesEventKey, type WorkspacesMessageKey, WorkspacesModule, schemas, toInvitationDTO, toMemberDTO, toRoleDTO, toSettingsDTO, toWorkspaceDTO };

package/dist/index.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
 // src/config.ts
 var MESSAGE_KEYS = {
   workspaceInvitation: "workspace-invitation"
@@ -7,7 +13,84 @@ var EVENT_KEYS = {
 };
 
 // src/routes.ts
-import { requireAuth } from "@fonderie/core/middlewares";
+import { requireAuth, validate } from "@fonderie/core/middlewares";
+
+// src/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  acceptInvitationSchema: () => acceptInvitationSchema,
+  addMemberRoleSchema: () => addMemberRoleSchema,
+  createInvitationsSchema: () => createInvitationsSchema,
+  createRoleSchema: () => createRoleSchema,
+  createWorkspaceSchema: () => createWorkspaceSchema,
+  setRolePermissionsSchema: () => setRolePermissionsSchema,
+  updateRoleSchema: () => updateRoleSchema,
+  updateSettingsSchema: () => updateSettingsSchema,
+  updateWorkspaceSchema: () => updateWorkspaceSchema
+});
+import { z } from "zod";
+var name = z.string().trim().min(1, "name is required").max(200);
+var email = z.string().trim().pipe(z.email());
+var createWorkspaceSchema = z.object({
+  name,
+  description: z.string().max(2e3).optional(),
+  // PERSONAL workspaces are created automatically by the module; the
+  // controller enforces the rule — schema just types the field.
+  type: z.string().max(40).optional()
+});
+var addressSchema = z.object({
+  line1: z.string().max(200).optional(),
+  line2: z.string().max(200).optional(),
+  city: z.string().max(100).optional(),
+  region: z.string().max(100).optional(),
+  postalCode: z.string().max(20).optional(),
+  country: z.string().max(60).optional()
+}).passthrough();
+var updateWorkspaceSchema = z.object({
+  name: z.string().trim().min(1).max(200).optional(),
+  description: z.string().max(2e3).nullable().optional(),
+  motto: z.string().max(300).nullable().optional(),
+  phone: z.string().max(32).nullable().optional(),
+  businessType: z.string().max(100).nullable().optional(),
+  address: addressSchema.nullable().optional()
+}).refine((o) => Object.values(o).some((v) => v !== void 0), "Provide at least one field");
+var updateSettingsSchema = z.object({
+  locale: z.string().max(35).optional(),
+  timezone: z.string().max(64).optional(),
+  currency: z.string().max(8).optional(),
+  dateFormat: z.string().max(32).optional(),
+  timeFormat: z.string().max(32).optional()
+}).refine((o) => Object.values(o).some((v) => v !== void 0), "No settings provided");
+var addMemberRoleSchema = z.object({ roleId: z.string().min(1, "roleId is required") });
+var inviteEntry = z.object({
+  email,
+  roleId: z.string().min(1).optional()
+});
+var createInvitationsSchema = z.union([
+  inviteEntry,
+  z.array(inviteEntry).min(1, "at least one invite is required")
+]);
+var acceptInvitationSchema = z.object({ pin: z.string().trim().min(1, "pin is required") });
+var createRoleSchema = z.object({
+  name,
+  description: z.string().max(1e3).optional()
+});
+var updateRoleSchema = z.object({
+  name: z.string().trim().min(1).max(200).optional(),
+  description: z.string().max(1e3).nullable().optional(),
+  active: z.boolean().optional()
+}).refine((o) => Object.values(o).some((v) => v !== void 0), "Provide at least one field");
+var setRolePermissionsSchema = z.object({
+  permissions: z.array(
+    z.object({
+      permissionKey: z.string().min(1),
+      canCreate: z.boolean().optional(),
+      canRead: z.boolean().optional(),
+      canUpdate: z.boolean().optional(),
+      canDelete: z.boolean().optional()
+    })
+  )
+});
 
 // src/middlewares/workspace-context.ts
 import { setApiResponse, HTTP } from "@fonderie/core";
@@ -421,10 +504,10 @@ async function createRole(opts, store) {
   if (!role) throw new Error("Failed to create role");
   return role;
 }
-async function findSystemRole(name, store) {
+async function findSystemRole(name2, store) {
   const [row] = await store.query(
     `SELECT ${SELECT_ROLE} FROM fonderie_roles WHERE name = $1 AND is_system = true LIMIT 1`,
-    [name]
+    [name2]
   );
   return row ?? null;
 }
@@ -513,8 +596,8 @@ var RoleModel = class {
   create(opts) {
     return createRole(opts, this.store);
   }
-  findSystem(name) {
-    return findSystemRole(name, this.store);
+  findSystem(name2) {
+    return findSystemRole(name2, this.store);
   }
   findById(id) {
     return getRoleById(id, this.store);
@@ -621,10 +704,10 @@ function workspaceController(store, config) {
     },
     async create(ctx) {
       const body = ctx.meta["body"];
-      const name = body?.["name"];
+      const name2 = body?.["name"];
       const description = body?.["description"];
       const type = body?.["type"];
-      if (typeof name !== "string" || name.trim().length === 0) {
+      if (typeof name2 !== "string" || name2.trim().length === 0) {
         return setApiResponse2(HTTP2.UNPROCESSABLE, "INVALID_PARAMETER", "name is required");
       }
       if (type === "PERSONAL") {
@@ -634,10 +717,10 @@ function workspaceController(store, config) {
           "Personal workspaces are created automatically"
         );
       }
-      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      const slug = name2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
       const workspace = await store.transaction(async (tx) => {
         const wsOpts = {
-          name: name.trim(),
+          name: name2.trim(),
           slug,
           ownerId: ctx.user.id,
           type: typeof type === "string" ? type : "ORGANIZATION"
@@ -676,7 +759,7 @@ function workspaceController(store, config) {
       if (body?.["businessType"] !== void 0)
         opts.businessType = typeof body["businessType"] === "string" ? body["businessType"] : null;
       if (body?.["address"] !== void 0 && typeof body["address"] === "object")
-        opts.address = body["address"];
+        opts.address = body["address"] ?? null;
       const workspace = await workspaces.update(ctx.workspace.id, opts);
       if (!workspace) return setApiResponse2(HTTP2.NOT_FOUND, "NOT_FOUND", "Workspace not found");
       return setApiResponse2(HTTP2.OK, "WORKSPACE_UPDATED", "Workspace updated successfully.", {
@@ -820,14 +903,14 @@ function roleController(store) {
         return setApiResponse4(HTTP4.NOT_FOUND, "NOT_FOUND", "Workspace not found");
       }
       const body = ctx.meta["body"];
-      const name = body?.["name"];
+      const name2 = body?.["name"];
       const description = body?.["description"];
-      if (typeof name !== "string" || name.trim().length === 0) {
+      if (typeof name2 !== "string" || name2.trim().length === 0) {
         return setApiResponse4(HTTP4.UNPROCESSABLE, "INVALID_PARAMETER", "name is required");
       }
       try {
         const opts = {
-          name: name.trim(),
+          name: name2.trim(),
           workspaceId: ctx.workspace.id
         };
         if (typeof description === "string") {
@@ -1132,21 +1215,21 @@ function invitationController(store, ttl, bus) {
       }
       const results = await Promise.all(
         entries.map(async (entry) => {
-          const email = entry["email"];
+          const email2 = entry["email"];
           const resolvedRoleId = entry["roleId"] ?? defaultRoleId;
           const invitation = await invitations.create({
             workspaceId: ctx.workspace.id,
-            email,
+            email: email2,
             roleId: resolvedRoleId,
             ttl
           });
           bus?.emit(NOTIFICATION_EVENT, {
             type: MESSAGE_KEYS.workspaceInvitation,
-            recipient: { email, phone: null, deviceToken: null },
+            recipient: { email: email2, phone: null, deviceToken: null },
             data: { token: invitation.token, pin: invitation.pin }
           }).catch(() => {
           });
-          return { invitationId: invitation.id, email };
+          return { invitationId: invitation.id, email: email2 };
         })
       );
       return setApiResponse5(HTTP5.CREATED, "INVITATIONS_SENT", "Invitations sent successfully.", {
@@ -1191,36 +1274,36 @@ function buildWorkspaceRoutes(store, config, bus) {
   const invitation = invitationController(store, ttl, bus);
   return [
     // ── Workspace creation + listing (no workspace context required)
-    ["POST", "/workspaces", requireAuth, workspace.create],
+    ["POST", "/workspaces", requireAuth, validate(createWorkspaceSchema), workspace.create],
     ["GET", "/workspaces", requireAuth, workspace.list],
     // ── Members (workspace resolved from X-Workspace-ID header)
     ["GET", "/workspaces/members", requireAuth, wsCtx, member.list],
     ["DELETE", "/workspaces/members/:userId", requireAuth, wsCtx, member.remove],
     ["GET", "/workspaces/members/:userId/roles", requireAuth, wsCtx, member.getUserRoles],
-    ["POST", "/workspaces/members/:userId/roles", requireAuth, wsCtx, member.addRole],
+    ["POST", "/workspaces/members/:userId/roles", requireAuth, wsCtx, validate(addMemberRoleSchema), member.addRole],
     ["DELETE", "/workspaces/members/:userId/roles/:roleId", requireAuth, wsCtx, member.removeRole],
     // ── Invitations
     ["GET", "/workspaces/invitations", requireAuth, wsCtx, invitation.list],
-    ["POST", "/workspaces/invitations", requireAuth, wsCtx, invitation.invite],
+    ["POST", "/workspaces/invitations", requireAuth, wsCtx, validate(createInvitationsSchema), invitation.invite],
     ["DELETE", "/workspaces/invitations/:inviteId", requireAuth, wsCtx, invitation.cancel],
-    ["POST", "/workspaces/invitations/accept", requireAuth, invitation.accept],
+    ["POST", "/workspaces/invitations/accept", requireAuth, validate(acceptInvitationSchema), invitation.accept],
     // ── Roles
-    ["POST", "/workspaces/roles", requireAuth, wsCtx, role.create],
+    ["POST", "/workspaces/roles", requireAuth, wsCtx, validate(createRoleSchema), role.create],
     ["GET", "/workspaces/roles", requireAuth, wsCtx, role.list],
     ["GET", "/workspaces/roles/:roleId", requireAuth, wsCtx, role.get],
-    ["PUT", "/workspaces/roles/:roleId", requireAuth, wsCtx, role.update],
+    ["PUT", "/workspaces/roles/:roleId", requireAuth, wsCtx, validate(updateRoleSchema), role.update],
     ["DELETE", "/workspaces/roles/:roleId", requireAuth, wsCtx, role.remove],
-    ["POST", "/workspaces/roles/:roleId/permissions", requireAuth, wsCtx, role.setPermissions],
+    ["POST", "/workspaces/roles/:roleId/permissions", requireAuth, wsCtx, validate(setRolePermissionsSchema), role.setPermissions],
     // ── Workspace lifecycle
     ["POST", "/workspaces/archive", requireAuth, wsCtx, workspace.archive],
     ["POST", "/workspaces/restore", requireAuth, wsCtx, workspace.restore],
     ["GET", "/workspaces/settings", requireAuth, wsCtx, workspace.getSettings],
-    ["PUT", "/workspaces/settings", requireAuth, wsCtx, workspace.updateSettings],
+    ["PUT", "/workspaces/settings", requireAuth, wsCtx, validate(updateSettingsSchema), workspace.updateSettings],
     // ── Path-based lookup by ID (admin / cross-workspace use)
     ["GET", "/workspaces/:id", requireAuth, wsCtx, workspace.get],
     // ── Update current workspace — ID resolved from X-Workspace-ID header
     // (or personal workspace fallback when header is absent)
-    ["PUT", "/workspaces", requireAuth, wsCtx, workspace.update]
+    ["PUT", "/workspaces", requireAuth, wsCtx, validate(updateWorkspaceSchema), workspace.update]
   ];
 }
 
@@ -1251,14 +1334,14 @@ var WorkspacesModule = class {
     }
   }
   async provisionPersonalWorkspace(payload) {
-    const name = "My Workspace";
+    const name2 = "My Workspace";
     const slug = `${payload.userId}-personal`;
     let workspaceId;
     await this.store.transaction(async (tx) => {
       const wsModel = new WorkspaceModel(tx);
       const roleModel = new RoleModel(tx);
       const memModel = new MemberModel(tx);
-      const ws = await wsModel.createPersonal({ name, slug, ownerId: payload.userId });
+      const ws = await wsModel.createPersonal({ name: name2, slug, ownerId: payload.userId });
       if (!ws) return;
       workspaceId = ws.id;
       const adminRole = await roleModel.findSystem("ADMIN");
@@ -1293,6 +1376,7 @@ export {
   MESSAGE_KEYS,
   WorkspacesModule,
   requireWorkspace,
+  schemas_exports as schemas,
   toInvitationDTO,
   toMemberDTO,
   toRoleDTO,