@jskit-ai/workspaces-core 0.1.30 → 0.1.32

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -1,82 +1,35 @@
-import { Type } from "@fastify/type-provider-typebox";
-import { encodeInviteTokenHash } from "@jskit-ai/auth-core/shared/inviteTokens";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+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 { normalizeObjectInput, recordIdSchema } from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
-function normalizePendingInvite(invite) {
-  const id = normalizeRecordId(invite?.id, { fallback: null });
-  const workspaceId = normalizeRecordId(invite?.workspaceId, { fallback: null });
-  const tokenHash = normalizeText(invite?.tokenHash);
-
-  if (!id || !workspaceId || !tokenHash) {
-    return null;
-  }
-
-  return {
-    id,
-    workspaceId,
-    workspaceSlug: normalizeText(invite?.workspaceSlug),
-    workspaceName: normalizeText(invite?.workspaceName || invite?.workspaceSlug),
-    workspaceAvatarUrl: normalizeText(invite?.workspaceAvatarUrl),
-    roleSid: normalizeLowerText(invite?.roleSid || "member") || "member",
-    status: normalizeLowerText(invite?.status || "pending") || "pending",
-    expiresAt: invite?.expiresAt || null,
-    token: encodeInviteTokenHash(tokenHash)
-  };
-}
-
-function normalizePendingInviteList(invites) {
-  return (Array.isArray(invites) ? invites : []).map((invite) => normalizePendingInvite(invite)).filter(Boolean);
-}
-
-const pendingInviteRecordValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      id: recordIdSchema,
-      workspaceId: recordIdSchema,
-      workspaceSlug: Type.String({ minLength: 1 }),
-      workspaceName: Type.String({ minLength: 1 }),
-      workspaceAvatarUrl: Type.String(),
-      roleSid: Type.String({ minLength: 1 }),
-      status: Type.String({ minLength: 1 }),
-      expiresAt: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
-      token: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  ),
-  normalize: normalizePendingInvite
-});
-
-const pendingInvitationsListOutputValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      pendingInvites: Type.Array(pendingInviteRecordValidator.schema)
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-
-    return {
-      pendingInvites: normalizePendingInviteList(source.pendingInvites)
-    };
+const pendingInvitationsListOutputSchema = createSchema({
+  pendingInvites: {
+    type: "array",
+    required: true,
+    items: createSchema({
+      id: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+      workspaceId: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+      workspaceSlug: { type: "string", required: true, minLength: 1, maxLength: 120 },
+      workspaceName: { type: "string", required: true, minLength: 1, maxLength: 160 },
+      workspaceAvatarUrl: { type: "string", required: true },
+      roleSid: { type: "string", required: true, minLength: 1, maxLength: 64 },
+      status: { type: "string", required: true, minLength: 1, maxLength: 64 },
+      expiresAt: { type: "string", required: false, nullable: true, minLength: 1 },
+      token: { type: "string", required: true, minLength: 1 }
+    })
   }
 });
 
-const WORKSPACE_PENDING_INVITATIONS_MESSAGES = createOperationMessages();
-
-const workspacePendingInvitationsResource = Object.freeze({
+const workspacePendingInvitationsResource = defineResource({
   namespace: "workspacePendingInvitations",
-  messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
-  operations: Object.freeze({
-    list: Object.freeze({
+  messages: createOperationMessages(),
+  operations: {
+    list: {
       method: "GET",
-      messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
-      outputValidator: pendingInvitationsListOutputValidator
-    })
-  })
+      output: pendingInvitationsListOutputSchema
+    }
+  }
 });
 
 export { workspacePendingInvitationsResource };

package/src/shared/resources/workspaceResource.js

@@ -1,12 +1,8 @@
-import { Type } from "typebox";
-import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  createCursorListValidator,
-  recordIdSchema,
-  recordIdInputSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+import { createSchema } from "json-rest-schema";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+import { createSchemaDefinition } from "@jskit-ai/resource-core/shared/resource";
 
 function normalizeWorkspaceAvatarUrl(value) {
   const avatarUrl = normalizeText(value);
@@ -23,154 +19,127 @@ function normalizeWorkspaceAvatarUrl(value) {
   }
 }
 
-function normalizeWorkspaceInput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "slug")) {
-    normalized.slug = normalizeLowerText(source.slug);
-  }
-  if (Object.hasOwn(source, "name")) {
-    normalized.name = normalizeText(source.name);
-  }
-  if (Object.hasOwn(source, "ownerUserId")) {
-    normalized.ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: "" });
-  }
-  if (Object.hasOwn(source, "avatarUrl")) {
-    normalized.avatarUrl = normalizeWorkspaceAvatarUrl(source.avatarUrl);
-  }
-  if (Object.hasOwn(source, "isPersonal")) {
-    normalized.isPersonal = source.isPersonal === true;
-  }
-
-  return normalized;
-}
-
-function normalizeWorkspaceOutput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeLowerText(source.slug),
-    name: normalizeText(source.name),
-    ownerUserId: normalizeRecordId(source.ownerUserId, { fallback: "" }),
-    avatarUrl: normalizeText(source.avatarUrl)
-  };
-}
-
-function normalizeWorkspaceListItemOutput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-
-  return {
-    id: normalizeRecordId(source.id, { fallback: "" }),
-    slug: normalizeLowerText(source.slug),
-    name: normalizeText(source.name),
-    avatarUrl: normalizeText(source.avatarUrl),
-    roleSid: normalizeLowerText(source.roleSid || "member") || "member",
-    isAccessible: source.isAccessible !== false
-  };
-}
-
-const responseRecordSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    ownerUserId: recordIdSchema,
-    avatarUrl: Type.String()
-  },
-  { additionalProperties: false }
-);
-
-const listItemSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    slug: Type.String({ minLength: 1 }),
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    avatarUrl: Type.String(),
-    roleSid: Type.String({ minLength: 1 }),
-    isAccessible: Type.Boolean()
-  },
-  { additionalProperties: false }
-);
-
-const createRequestBodySchema = Type.Object(
-  {
-    name: Type.String({ minLength: 1, maxLength: 160 }),
-    slug: Type.Optional(Type.String({ minLength: 1, maxLength: 120 })),
-    ownerUserId: Type.Optional(recordIdInputSchema)
-  },
-  { additionalProperties: false }
-);
+const workspaceOutputSchema = 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 patchRequestBodySchema = Type.Object(
-  {
-    name: Type.Optional(Type.String({ minLength: 1, maxLength: 160 })),
-    avatarUrl: Type.Optional(
-      Type.String({
-        pattern: "^(https?://.+)?$",
-        messages: {
-          pattern: "Workspace avatar URL must be a valid absolute URL (http:// or https://).",
-          default: "Workspace avatar URL must be a valid absolute URL (http:// or https://)."
-        }
-      })
-    )
-  },
-  { additionalProperties: false }
-);
+const workspaceListItemSchema = 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 },
+  avatarUrl: { type: "string", required: true },
+  roleSid: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  isAccessible: { type: "boolean", required: true }
+});
 
-const responseRecordValidator = Object.freeze({
-  schema: responseRecordSchema,
-  normalize: normalizeWorkspaceOutput
+const workspaceCreateBodySchema = createSchema({
+  name: { type: "string", required: true, minLength: 1, maxLength: 160 },
+  slug: { type: "string", required: false, lowercase: true, minLength: 1, maxLength: 120 },
+  ownerUserId: { type: "id", required: false }
 });
 
-const workspaceSummaryOutputValidator = Object.freeze({
-  schema: listItemSchema,
-  normalize: normalizeWorkspaceListItemOutput
+const workspacePatchBodySchema = createSchema({
+  name: { type: "string", required: false, minLength: 1, maxLength: 160 },
+  avatarUrl: {
+    type: "string",
+    required: false,
+    pattern: "^(https?://.+)?$",
+    messages: {
+      pattern: "Workspace avatar URL must be a valid absolute URL (http:// or https://).",
+      default: "Workspace avatar URL must be a valid absolute URL (http:// or https://)."
+    }
+  }
 });
 
-const resource = {
+const workspaceListItemOutputValidator = createSchemaDefinition(workspaceListItemSchema, "replace");
+
+const resource = defineCrudResource({
   namespace: "workspace",
-  messages: {
-    validation: "Fix invalid workspace values and try again.",
-    saveSuccess: "Workspace updated.",
-    saveError: "Unable to update workspace.",
-    apiValidation: "Validation failed."
+  tableName: "workspaces",
+  searchSchema: {
+    id: { type: "id", actualField: "id" }
   },
-  operations: {
-    view: {
-      method: "GET",
-      outputValidator: responseRecordValidator
+  schema: {
+    slug: {
+      type: "string",
+      required: true,
+      max: 120,
+      search: true,
+      setter: (value) => normalizeLowerText(value)
+    },
+    name: {
+      type: "string",
+      required: true,
+      max: 160,
+      search: true,
+      setter: (value) => normalizeText(value)
     },
-    list: {
-      method: "GET",
-      outputValidator: createCursorListValidator(workspaceSummaryOutputValidator)
+    ownerUserId: {
+      type: "id",
+      required: true,
+      search: true,
+      belongsTo: "userProfiles",
+      as: "owner",
+      storage: { column: "owner_user_id" }
     },
-    create: {
-      method: "POST",
-      bodyValidator: {
-        schema: createRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
+    isPersonal: {
+      type: "boolean",
+      defaultTo: false,
+      search: true,
+      storage: { column: "is_personal" }
     },
-    replace: {
-      method: "PUT",
-      bodyValidator: {
-        schema: createRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
+    avatarUrl: {
+      type: "string",
+      max: 512,
+      defaultTo: "",
+      storage: { column: "avatar_url" },
+      setter: (value) => normalizeWorkspaceAvatarUrl(value)
     },
-    patch: {
-      method: "PATCH",
-      bodyValidator: {
-        schema: patchRequestBodySchema,
-        normalize: normalizeWorkspaceInput
-      },
-      outputValidator: responseRecordValidator
+    createdAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "created_at",
+        writeSerializer: "datetime-utc"
+      }
+    },
+    updatedAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "updated_at",
+        writeSerializer: "datetime-utc"
+      }
+    },
+    deletedAt: {
+      type: "dateTime",
+      nullable: true,
+      search: true,
+      storage: {
+        column: "deleted_at",
+        writeSerializer: "datetime-utc"
+      }
     }
+  },
+  messages: {
+    validation: "Fix invalid workspace values and try again.",
+    saveSuccess: "Workspace updated.",
+    saveError: "Unable to update workspace.",
+    apiValidation: "Validation failed."
+  },
+  crudOperations: ["view", "list", "create", "replace", "patch"],
+  crud: {
+    output: workspaceOutputSchema,
+    listItemOutput: workspaceListItemOutputValidator,
+    createBody: workspaceCreateBodySchema,
+    replaceBody: workspaceCreateBodySchema,
+    patchBody: workspacePatchBodySchema
   }
-};
+});
 
 export { resource as workspaceResource };
+export { workspaceListItemOutputValidator };

package/src/shared/resources/workspaceRoleCatalogSchema.js

@@ -0,0 +1,31 @@
+import { createSchema } from "json-rest-schema";
+
+const workspaceRoleDescriptorSchema = createSchema({
+  id: { type: "string", required: true, minLength: 1, maxLength: 64 },
+  assignable: { type: "boolean", required: true },
+  permissions: {
+    type: "array",
+    required: true,
+    items: { type: "string", minLength: 1 }
+  }
+});
+
+const workspaceRoleCatalogSchema = createSchema({
+  collaborationEnabled: { type: "boolean", required: true },
+  defaultInviteRole: { type: "string", required: true, minLength: 0, maxLength: 64 },
+  roles: {
+    type: "array",
+    required: true,
+    items: workspaceRoleDescriptorSchema
+  },
+  assignableRoleIds: {
+    type: "array",
+    required: true,
+    items: { type: "string", minLength: 1, maxLength: 64 }
+  }
+});
+
+export {
+  workspaceRoleCatalogSchema,
+  workspaceRoleDescriptorSchema
+};