@jskit-ai/workspaces-core 0.1.31 → 0.1.32

package/src/shared/resources/workspaceMembersResource.js

@@ -1,354 +1,219 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  recordIdSchema,
-  recordIdInputSchema,
-  nullableRecordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
+import { createSchema } from "json-rest-schema";
+import { defineResource } from "@jskit-ai/resource-core/shared/resource";
 import { createOperationMessages } from "../operationMessages.js";
-import { createWorkspaceRoleCatalog, OWNER_ROLE_ID } from "../roles.js";
+import { workspaceRoleCatalogSchema } from "./workspaceRoleCatalogSchema.js";
+
+const workspaceSummaryOutputSchema = createSchema({
+  id: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+  slug: { type: "string", required: true, minLength: 1, maxLength: 120 },
+  name: { type: "string", required: true, minLength: 1, maxLength: 160 },
+  ownerUserId: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+  avatarUrl: { type: "string", required: true }
+});
 
-const workspaceSummaryOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1 }),
-    ownerUserId: recordIdSchema,
-    avatarUrl: Type.String()
-  },
-  { additionalProperties: false }
-);
+const memberSummaryOutputSchema = createSchema({
+  userId: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+  roleSid: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  status: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  displayName: { type: "string", required: true },
+  email: { type: "string", required: true, minLength: 1, maxLength: 255 },
+  isOwner: { type: "boolean", required: true }
+});
 
-const memberSummaryOutputSchema = Type.Object(
-  {
-    userId: recordIdSchema,
-    roleSid: Type.String({ minLength: 1 }),
-    status: Type.String({ minLength: 1 }),
-    displayName: Type.String(),
-    email: Type.String({ minLength: 1 }),
-    isOwner: Type.Boolean()
-  },
-  { additionalProperties: false }
-);
+const inviteSummaryOutputSchema = createSchema({
+  id: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+  email: { type: "string", required: true, minLength: 3, maxLength: 255 },
+  roleSid: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  status: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  expiresAt: { type: "string", required: true, minLength: 1 },
+  invitedByUserId: { type: "string", required: false, nullable: true, minLength: 1, pattern: RECORD_ID_PATTERN }
+});
 
-const inviteSummaryOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    email: Type.String({ minLength: 3, format: "email" }),
-    roleSid: Type.String({ minLength: 1 }),
-    status: Type.String({ minLength: 1 }),
-    expiresAt: Type.String({ minLength: 1 }),
-    invitedByUserId: nullableRecordIdSchema
+const workspaceMembersOutputSchema = createSchema({
+  workspace: {
+    type: "object",
+    required: true,
+    schema: workspaceSummaryOutputSchema
   },
-  { additionalProperties: false }
-);
-
-function normalizeWorkspaceAdminSummary(workspace) {
-  const source = normalizeObjectInput(workspace);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeText(source.slug),
-    name: normalizeText(source.name),
-    ownerUserId: normalizeRecordId(source.ownerUserId, { fallback: "" }),
-    avatarUrl: normalizeText(source.avatarUrl)
-  };
-}
-
-function normalizeMemberSummary(member, workspace) {
-  const source = normalizeObjectInput(member);
-  const userId = normalizeRecordId(source.userId, { fallback: "" });
-
-  return {
-    userId,
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    status: normalizeLowerText(source.status || "active") || "active",
-    displayName: normalizeText(source.displayName),
-    email: normalizeLowerText(source.email),
-    isOwner: userId === workspace.ownerUserId || normalizeLowerText(source.roleSid) === OWNER_ROLE_ID
-  };
-}
-
-function normalizeInviteSummary(invite) {
-  const source = normalizeObjectInput(invite);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    email: normalizeLowerText(source.email),
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    status: normalizeLowerText(source.status || "pending") || "pending",
-    expiresAt: source.expiresAt,
-    invitedByUserId: source.invitedByUserId == null ? null : normalizeRecordId(source.invitedByUserId, { fallback: null })
-  };
-}
-
-function normalizeWorkspaceOutputEnvelope(
-  payload = {},
-  { itemsKey, normalizeItem, includeInviteTokenPreview = false } = {}
-) {
-  const source = normalizeObjectInput(payload);
-  const workspace = normalizeWorkspaceAdminSummary(source.workspace);
-  const items = Array.isArray(source[itemsKey]) ? source[itemsKey] : [];
-  const roleCatalog = normalizeObjectInput(source.roleCatalog);
-  const hasRoleCatalog =
-    Array.isArray(roleCatalog.roles) &&
-    roleCatalog.roles.length > 0 &&
-    Array.isArray(roleCatalog.assignableRoleIds);
-  const normalized = {
-    workspace,
-    [itemsKey]: items.map((item) => normalizeItem(item, workspace)),
-    roleCatalog: hasRoleCatalog ? roleCatalog : createWorkspaceRoleCatalog()
-  };
-
-  if (includeInviteTokenPreview && Object.hasOwn(source, "inviteTokenPreview")) {
-    normalized.inviteTokenPreview = normalizeText(source.inviteTokenPreview);
+  members: {
+    type: "array",
+    required: true,
+    items: memberSummaryOutputSchema
+  },
+  roleCatalog: {
+    type: "object",
+    required: true,
+    schema: workspaceRoleCatalogSchema
   }
-
-  return normalized;
-}
-
-function normalizeWorkspaceMembersOutput(payload = {}) {
-  return normalizeWorkspaceOutputEnvelope(payload, {
-    itemsKey: "members",
-    normalizeItem: normalizeMemberSummary
-  });
-}
-
-function normalizeWorkspaceInvitesOutput(payload = {}) {
-  return normalizeWorkspaceOutputEnvelope(payload, {
-    itemsKey: "invites",
-    normalizeItem: normalizeInviteSummary,
-    includeInviteTokenPreview: true
-  });
-}
-
-const workspaceRoleCatalogOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      collaborationEnabled: Type.Boolean(),
-      defaultInviteRole: Type.String(),
-      roles: Type.Array(Type.Object({}, { additionalProperties: true })),
-      assignableRoleIds: Type.Array(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: true }
-  )
-});
-
-const workspaceMembersOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspace: workspaceSummaryOutputSchema,
-      members: Type.Array(memberSummaryOutputSchema),
-      roleCatalog: workspaceRoleCatalogOutputValidator.schema
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceMembersOutput
 });
 
-const workspaceInvitesOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      workspace: workspaceSummaryOutputSchema,
-      invites: Type.Array(inviteSummaryOutputSchema),
-      roleCatalog: workspaceRoleCatalogOutputValidator.schema,
-      inviteTokenPreview: Type.Optional(Type.String({ minLength: 1 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizeWorkspaceInvitesOutput
+const workspaceInvitesListOutputSchema = createSchema({
+  workspace: {
+    type: "object",
+    required: true,
+    schema: workspaceSummaryOutputSchema
+  },
+  invites: {
+    type: "array",
+    required: true,
+    items: inviteSummaryOutputSchema
+  },
+  roleCatalog: {
+    type: "object",
+    required: true,
+    schema: workspaceRoleCatalogSchema
+  }
 });
 
-const updateMemberRoleBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      roleSid: normalizeLowerText(source.roleSid)
-    };
+const workspaceInviteCreateOutputSchema = createSchema({
+  workspace: {
+    type: "object",
+    required: true,
+    schema: workspaceSummaryOutputSchema
+  },
+  invites: {
+    type: "array",
+    required: true,
+    items: inviteSummaryOutputSchema
+  },
+  roleCatalog: {
+    type: "object",
+    required: true,
+    schema: workspaceRoleCatalogSchema
+  },
+  inviteTokenPreview: {
+    type: "string",
+    required: true,
+    minLength: 1
+  },
+  createdInviteId: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    pattern: RECORD_ID_PATTERN
   }
 });
 
-const updateMemberRoleInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      memberUserId: recordIdInputSchema,
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      memberUserId: normalizeRecordId(source.memberUserId, { fallback: "" }),
-      roleSid: normalizeLowerText(source.roleSid)
-    };
+const workspaceInviteRevokeOutputSchema = createSchema({
+  workspace: {
+    type: "object",
+    required: true,
+    schema: workspaceSummaryOutputSchema
+  },
+  invites: {
+    type: "array",
+    required: true,
+    items: inviteSummaryOutputSchema
+  },
+  roleCatalog: {
+    type: "object",
+    required: true,
+    schema: workspaceRoleCatalogSchema
+  },
+  revokedInviteId: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    pattern: RECORD_ID_PATTERN
   }
 });
 
-const removeMemberInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      memberUserId: recordIdInputSchema
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      memberUserId: normalizeRecordId(source.memberUserId, { fallback: "" })
-    };
-  }
+const updateMemberRoleBodySchema = createSchema({
+  roleSid: { type: "string", required: true, minLength: 1, lowercase: true }
 });
 
-const createInviteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: Type.String({ minLength: 3, format: "email" }),
-      roleSid: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
+const updateMemberRoleInputSchema = createSchema({
+  memberUserId: { type: "id", required: true },
+  roleSid: { type: "string", required: true, minLength: 1, lowercase: true }
+});
 
-    return {
-      email: normalizeLowerText(source.email),
-      roleSid: normalizeLowerText(source.roleSid || "member") || "member"
-    };
-  }
+const removeMemberInputSchema = createSchema({
+  memberUserId: { type: "id", required: true }
 });
 
-const revokeInviteInputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      inviteId: recordIdInputSchema
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
+const createInviteBodySchema = createSchema({
+  email: { type: "string", required: true, minLength: 3, lowercase: true },
+  roleSid: { type: "string", required: true, minLength: 1, lowercase: true }
+});
 
-    return {
-      inviteId: normalizeRecordId(source.inviteId, { fallback: "" })
-    };
-  }
+const revokeInviteInputSchema = createSchema({
+  inviteId: { type: "id", required: true }
 });
 
-const redeemInviteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      token: Type.String({
-        minLength: 1,
-        messages: {
-          required: "Invite token is required.",
-          minLength: "Invite token is required.",
-          default: "Invite token is invalid."
-        }
-      }),
-      decision: Type.Union([Type.Literal("accept"), Type.Literal("refuse")], {
-        messages: {
-          required: "Decision is required.",
-          default: "Decision must be accept or refuse."
-        }
-      })
-    },
-    {
-      additionalProperties: false,
-      messages: {
-        additionalProperties: "Unexpected field."
-      }
+const redeemInviteBodySchema = createSchema({
+  token: {
+    type: "string",
+    required: true,
+    minLength: 1,
+    messages: {
+      required: "Invite token is required.",
+      minLength: "Invite token is required.",
+      default: "Invite token is invalid."
+    }
+  },
+  decision: {
+    type: "string",
+    required: true,
+    enum: ["accept", "refuse"],
+    messages: {
+      required: "Decision is required.",
+      default: "Decision must be accept or refuse."
     }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      token: normalizeText(source.token),
-      decision: normalizeLowerText(source.decision)
-    };
   }
 });
 
-const redeemInviteOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      decision: Type.Union([Type.Literal("accepted"), Type.Literal("refused")])
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      decision: normalizeLowerText(source.decision)
-    };
+const redeemInviteOutputSchema = createSchema({
+  decision: {
+    type: "string",
+    required: true,
+    enum: ["accepted", "refused"]
   }
 });
 
-const WORKSPACE_MEMBERS_MESSAGES = createOperationMessages();
-
-const workspaceMembersResource = Object.freeze({
+const workspaceMembersResource = defineResource({
   namespace: "workspaceMembers",
-  messages: WORKSPACE_MEMBERS_MESSAGES,
-  operations: Object.freeze({
-    rolesList: Object.freeze({
+  messages: createOperationMessages(),
+  operations: {
+    rolesList: {
       method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceRoleCatalogOutputValidator
-    }),
-    membersList: Object.freeze({
+      output: workspaceRoleCatalogSchema
+    },
+    membersList: {
       method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    updateMemberRole: Object.freeze({
+      output: workspaceMembersOutputSchema
+    },
+    updateMemberRole: {
       method: "PATCH",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: updateMemberRoleBodyValidator,
-      inputValidator: updateMemberRoleInputValidator,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    removeMember: Object.freeze({
+      body: updateMemberRoleBodySchema,
+      input: updateMemberRoleInputSchema,
+      output: workspaceMembersOutputSchema
+    },
+    removeMember: {
       method: "DELETE",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      inputValidator: removeMemberInputValidator,
-      outputValidator: workspaceMembersOutputValidator
-    }),
-    invitesList: Object.freeze({
+      input: removeMemberInputSchema,
+      output: workspaceMembersOutputSchema
+    },
+    invitesList: {
       method: "GET",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    createInvite: Object.freeze({
+      output: workspaceInvitesListOutputSchema
+    },
+    createInvite: {
       method: "POST",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: createInviteBodyValidator,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    revokeInvite: Object.freeze({
+      body: createInviteBodySchema,
+      output: workspaceInviteCreateOutputSchema
+    },
+    revokeInvite: {
       method: "DELETE",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      inputValidator: revokeInviteInputValidator,
-      outputValidator: workspaceInvitesOutputValidator
-    }),
-    redeemInvite: Object.freeze({
+      input: revokeInviteInputSchema,
+      output: workspaceInviteRevokeOutputSchema
+    },
+    redeemInvite: {
       method: "POST",
-      messages: WORKSPACE_MEMBERS_MESSAGES,
-      bodyValidator: redeemInviteBodyValidator,
-      outputValidator: redeemInviteOutputValidator
-    })
-  })
+      body: redeemInviteBodySchema,
+      output: redeemInviteOutputSchema
+    }
+  }
 });
 
 export { workspaceMembersResource };

package/src/shared/resources/workspaceMembershipsResource.js

@@ -0,0 +1,96 @@
+import { normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const workspaceMembershipsResource = defineCrudResource({
+  namespace: "workspaceMemberships",
+  tableName: "workspace_memberships",
+  searchSchema: {
+    id: { type: "id", actualField: "id" }
+  },
+  schema: {
+    workspaceId: {
+      type: "id",
+      required: true,
+      search: true,
+      belongsTo: "workspaces",
+      as: "workspace",
+      operations: {
+        output: { required: true },
+        create: { required: true }
+      }
+    },
+    userId: {
+      type: "id",
+      required: true,
+      search: true,
+      belongsTo: "userProfiles",
+      as: "user",
+      operations: {
+        output: { required: true },
+        create: { required: true }
+      }
+    },
+    roleSid: {
+      type: "string",
+      required: true,
+      max: 64,
+      defaultTo: "member",
+      search: true,
+      storage: { column: "role_sid" },
+      setter: (value) => normalizeLowerText(value),
+      operations: {
+        output: { required: true },
+        create: { required: true },
+        patch: { required: false }
+      }
+    },
+    status: {
+      type: "string",
+      required: true,
+      max: 32,
+      defaultTo: "active",
+      search: true,
+      setter: (value) => normalizeLowerText(value),
+      operations: {
+        output: { required: true },
+        create: { required: true },
+        patch: { required: false }
+      }
+    },
+    createdAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "created_at",
+        writeSerializer: "datetime-utc"
+      },
+      operations: {
+        output: { required: true },
+        create: { required: false }
+      }
+    },
+    updatedAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "updated_at",
+        writeSerializer: "datetime-utc"
+      },
+      operations: {
+        output: { required: true },
+        create: { required: false },
+        patch: { required: false }
+      }
+    }
+  },
+  messages: {
+    validation: "Fix invalid values and try again.",
+    saveSuccess: "Record saved.",
+    saveError: "Unable to save record.",
+    deleteSuccess: "Record deleted.",
+    deleteError: "Unable to delete record."
+  },
+  crudOperations: ["list", "view", "create", "patch"]
+});
+
+export { workspaceMembershipsResource };