@jskit-ai/workspaces-core 0.1.31 → 0.1.32

package/package.descriptor.mjs

@@ -1,10 +1,13 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/workspaces-core",
-  version: "0.1.31",
+  version: "0.1.32",
   kind: "runtime",
   description: "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
   dependsOn: [
+    "@jskit-ai/json-rest-api-core",
+    "@jskit-ai/resource-core",
+    "@jskit-ai/resource-crud-core",
     "@jskit-ai/users-core"
   ],
   capabilities: {
@@ -13,7 +16,8 @@ export default Object.freeze({
       "workspaces.server-routes"
     ],
     requires: [
-      "users.core"
+      "users.core",
+      "json-rest-api.core"
     ]
   },
   runtime: {
@@ -112,7 +116,10 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/users-core": "0.1.65"
+        "@jskit-ai/json-rest-api-core": "0.1.1",
+        "@jskit-ai/resource-core": "0.1.1",
+        "@jskit-ai/resource-crud-core": "0.1.1",
+        "@jskit-ai/users-core": "0.1.66"
       },
       dev: {}
     },
@@ -147,18 +154,10 @@ export default Object.freeze({
         from: "templates/migrations/workspaces_core_workspaces_drop_color.cjs",
         toDir: "migrations",
         extension: ".cjs",
-        reason: "Drop legacy workspaces.color now that workspace theme colors live in workspace_settings.",
+        reason: "Drop workspaces.color now that workspace theme colors live in workspace_settings.",
         category: "migration",
         id: "users-core-workspaces-drop-color"
       },
-      {
-        from: "templates/packages/main/src/shared/resources/workspaceSettingsFields.js",
-        to: "packages/main/src/shared/resources/workspaceSettingsFields.js",
-        preserveOnRemove: true,
-        reason: "Install app-owned workspace settings field definitions.",
-        category: "workspaces-core",
-        id: "users-core-app-owned-workspace-settings-fields"
-      },
       {
         from: "templates/config/roles.js",
         to: "config/roles.js",
@@ -169,16 +168,6 @@ export default Object.freeze({
       }
     ],
     text: [
-      {
-        op: "append-text",
-        file: "packages/main/src/shared/index.js",
-        position: "top",
-        skipIfContains: "import \"./resources/workspaceSettingsFields.js\";",
-        value: "import \"./resources/workspaceSettingsFields.js\";\n",
-        reason: "Load app-owned workspace settings field definitions inside the main shared module.",
-        category: "workspaces-core",
-        id: "users-core-main-shared-workspace-settings-field-import"
-      },
       {
         op: "append-text",
         file: "config/public.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -9,20 +9,22 @@
     "./server/WorkspacesCoreServiceProvider": "./src/server/WorkspacesCoreServiceProvider.js",
     "./server/validators/routeParamsValidator": "./src/server/common/validators/routeParamsValidator.js",
     "./server/support/workspaceRouteInput": "./src/server/support/workspaceRouteInput.js",
+    "./shared/jsonApiTransports": "./src/shared/jsonApiTransports.js",
     "./shared/settings": "./src/shared/settings.js",
     "./shared/tenancyProfile": "./src/shared/tenancyProfile.js",
     "./shared/support/workspacePathModel": "./src/shared/support/workspacePathModel.js",
     "./shared/resources/workspaceResource": "./src/shared/resources/workspaceResource.js",
-    "./shared/resources/workspaceSettingsFields": "./src/shared/resources/workspaceSettingsFields.js",
     "./shared/resources/workspaceSettingsResource": "./src/shared/resources/workspaceSettingsResource.js"
   },
   "dependencies": {
-    "@fastify/type-provider-typebox": "^6.1.0",
-    "@jskit-ai/auth-core": "0.1.54",
-    "@jskit-ai/database-runtime": "0.1.55",
-    "@jskit-ai/http-runtime": "0.1.54",
-    "@jskit-ai/kernel": "0.1.55",
-    "@jskit-ai/users-core": "0.1.65",
-    "typebox": "^1.0.81"
+    "@jskit-ai/auth-core": "0.1.55",
+    "@jskit-ai/database-runtime": "0.1.56",
+    "@jskit-ai/http-runtime": "0.1.55",
+    "@jskit-ai/json-rest-api-core": "0.1.1",
+    "@jskit-ai/kernel": "0.1.56",
+    "@jskit-ai/resource-crud-core": "0.1.1",
+    "@jskit-ai/resource-core": "0.1.1",
+    "@jskit-ai/users-core": "0.1.66",
+    "json-rest-schema": "1.x.x"
   }
 }

package/src/server/WorkspacesCoreServiceProvider.js

@@ -1,3 +1,9 @@
+import {
+  INTERNAL_JSON_REST_API,
+  addResourceIfMissing,
+  createJsonRestResourceScopeOptions
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
 import { bootWorkspaceDirectoryRoutes } from "./workspaceDirectory/bootWorkspaceDirectoryRoutes.js";
 import { registerWorkspaceDirectory } from "./workspaceDirectory/registerWorkspaceDirectory.js";
 import {
@@ -11,13 +17,17 @@ import { bootWorkspaceSettings } from "./workspaceSettings/bootWorkspaceSettings
 import { registerWorkspaceRepositories } from "./registerWorkspaceRepositories.js";
 import { registerWorkspaceCore } from "./registerWorkspaceCore.js";
 import { registerWorkspaceBootstrap } from "./registerWorkspaceBootstrap.js";
+import { workspaceResource } from "../shared/resources/workspaceResource.js";
+import { workspaceMembershipsResource } from "../shared/resources/workspaceMembershipsResource.js";
+import { workspaceInvitesResource } from "../shared/resources/workspaceInvitesResource.js";
+import { workspaceSettingsResource } from "../shared/resources/workspaceSettingsResource.js";
 
 class WorkspacesCoreServiceProvider {
   static id = "workspaces.core";
 
-  static dependsOn = ["users.core"];
+  static dependsOn = ["users.core", "json-rest-api.core"];
 
-  register(app) {
+  async register(app) {
     registerWorkspaceRepositories(app);
     registerWorkspaceCore(app);
     registerWorkspaceBootstrap(app);
@@ -28,6 +38,16 @@ class WorkspacesCoreServiceProvider {
   }
 
   async boot(app) {
+    const api = app.make(INTERNAL_JSON_REST_API);
+    const scopeOptions = {
+      writeSerializers: {
+        "datetime-utc": toDatabaseDateTimeUtc
+      }
+    };
+    await addResourceIfMissing(api, "workspaces", createJsonRestResourceScopeOptions(workspaceResource, scopeOptions));
+    await addResourceIfMissing(api, "workspaceMemberships", createJsonRestResourceScopeOptions(workspaceMembershipsResource, scopeOptions));
+    await addResourceIfMissing(api, "workspaceInvites", createJsonRestResourceScopeOptions(workspaceInvitesResource, scopeOptions));
+    await addResourceIfMissing(api, "workspaceSettings", createJsonRestResourceScopeOptions(workspaceSettingsResource, scopeOptions));
     if (app.make("workspaces.enabled") !== true) {
       return;
     }

package/src/server/common/repositories/workspaceInvitesRepository.js

@@ -1,26 +1,70 @@
-import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
+  createWithTransaction,
   normalizeLowerText,
   normalizeRecordId,
+  normalizeDbRecordId,
   normalizeText,
   nowDb,
-  isDuplicateEntryError
+  isDuplicateEntryError,
+  toIsoString
 } from "./repositoryUtils.js";
-import { workspaceInvitesResource } from "../resources/workspaceInvitesResource.js";
+import {
+  createJsonApiInputRecord,
+  createJsonApiRelationship,
+  createJsonRestContext,
+  simplifyJsonApiDocument
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 
-const REPOSITORY_CONFIG = Object.freeze({
-  context: "internal.repository.workspace-invites"
-});
+const RESOURCE_TYPE = "workspaceInvites";
 
 function normalizeInviteRecord(payload) {
   if (!payload) {
     return null;
   }
-  return workspaceInvitesResource.operations.view.outputValidator.normalize(payload);
+
+  return {
+    id: normalizeDbRecordId(payload.id, { fallback: null }),
+    workspaceId: normalizeDbRecordId(payload?.workspace?.id || payload?.workspaceId, { fallback: null }),
+    email: normalizeLowerText(payload.email),
+    roleSid: normalizeLowerText(payload.roleSid || "member") || "member",
+    status: normalizeLowerText(payload.status || "pending") || "pending",
+    tokenHash: normalizeText(payload.tokenHash),
+    invitedByUserId: normalizeDbRecordId(payload?.invitedByUser?.id || payload?.invitedByUserId, { fallback: null }),
+    expiresAt: payload.expiresAt ? toIsoString(payload.expiresAt) : null,
+    acceptedAt: payload.acceptedAt ? toIsoString(payload.acceptedAt) : null,
+    revokedAt: payload.revokedAt ? toIsoString(payload.revokedAt) : null,
+    createdAt: payload.createdAt ? toIsoString(payload.createdAt) : null,
+    updatedAt: payload.updatedAt ? toIsoString(payload.updatedAt) : null
+  };
 }
 
 function normalizeInvitePatchPayload(payload = {}) {
-  return workspaceInvitesResource.operations.patch.bodyValidator.normalize(payload);
+  const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const normalized = {};
+
+  if (Object.hasOwn(source, "roleSid")) {
+    normalized.roleSid = normalizeLowerText(source.roleSid);
+  }
+  if (Object.hasOwn(source, "status")) {
+    normalized.status = normalizeLowerText(source.status);
+  }
+  if (Object.hasOwn(source, "invitedByUserId")) {
+    normalized.invitedByUserId =
+      source.invitedByUserId == null
+        ? null
+        : normalizeRecordId(source.invitedByUserId, { fallback: null });
+  }
+  if (Object.hasOwn(source, "expiresAt")) {
+    normalized.expiresAt = source.expiresAt == null ? null : new Date(source.expiresAt);
+  }
+  if (Object.hasOwn(source, "acceptedAt")) {
+    normalized.acceptedAt = source.acceptedAt == null ? null : new Date(source.acceptedAt);
+  }
+  if (Object.hasOwn(source, "revokedAt")) {
+    normalized.revokedAt = source.revokedAt == null ? null : new Date(source.revokedAt);
+  }
+
+  return normalized;
 }
 
 function normalizeInviteWithWorkspace(payload = {}) {
@@ -31,48 +75,82 @@ function normalizeInviteWithWorkspace(payload = {}) {
 
   return {
     ...invite,
-    workspaceSlug: payload?.workspace_slug ? normalizeText(payload.workspace_slug) : undefined,
-    workspaceName: payload?.workspace_name ? normalizeText(payload.workspace_name) : undefined,
-    workspaceAvatarUrl: payload?.workspace_avatar_url ? normalizeText(payload.workspace_avatar_url) : undefined
+    workspaceSlug: payload?.workspace?.slug ? normalizeText(payload.workspace.slug) : undefined,
+    workspaceName: payload?.workspace?.name ? normalizeText(payload.workspace.name) : undefined,
+    workspaceAvatarUrl: payload?.workspace?.avatarUrl ? normalizeText(payload.workspace.avatarUrl) : undefined
   };
 }
 
-const WORKSPACE_INVITE_WITH_WORKSPACE_SELECT = Object.freeze([
-  "wi.*",
-  "w.slug as workspace_slug",
-  "w.name as workspace_name",
-  "w.avatar_url as workspace_avatar_url"
-]);
+function createInviteRelationships({ workspaceId = null, invitedByUserId = undefined } = {}) {
+  const relationships = {};
 
-function createRepository(knex) {
+  if (workspaceId) {
+    relationships.workspace = createJsonApiRelationship("workspaces", workspaceId);
+  }
+  if (invitedByUserId !== undefined) {
+    relationships.invitedByUser = createJsonApiRelationship("userProfiles", invitedByUserId);
+  }
+
+  return relationships;
+}
+
+function createRepository({ api, knex } = {}) {
+  if (!api?.resources?.workspaceInvites) {
+    throw new TypeError("workspaceInvitesRepository requires json-rest-api workspaceInvites resource.");
+  }
   if (typeof knex !== "function") {
     throw new TypeError("workspaceInvitesRepository requires knex.");
   }
-  const resourceRuntime = createCrudResourceRuntime(workspaceInvitesResource, knex, REPOSITORY_CONFIG);
-  const withTransaction = resourceRuntime.withTransaction;
+
+  const withTransaction = createWithTransaction(knex);
+
+  async function queryInvites(filters = {}, options = {}, { includeWorkspace = false } = {}) {
+    const result = await api.resources.workspaceInvites.query(
+      {
+        queryParams: {
+          filters,
+          ...(includeWorkspace ? { include: ["workspace"] } : {})
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    return Array.isArray(simplifyJsonApiDocument(result)) ? simplifyJsonApiDocument(result) : [];
+  }
 
   async function findPendingByTokenHash(tokenHash, options = {}) {
-    const client = options?.trx || knex;
-    const row = await client("workspace_invites")
-      .where({ token_hash: normalizeText(tokenHash), status: "pending" })
-      .first();
-    return normalizeInviteRecord(row);
+    const rows = await queryInvites(
+      {
+        tokenHash: normalizeText(tokenHash),
+        status: "pending"
+      },
+      options
+    );
+
+    return normalizeInviteRecord(rows[0] || null);
   }
 
   async function listPendingByEmail(email, options = {}) {
-    const client = options?.trx || knex;
     const normalizedEmail = normalizeLowerText(email);
     if (!normalizedEmail) {
       return [];
     }
 
-    const rows = await client("workspace_invites as wi")
-      .join("workspaces as w", "w.id", "wi.workspace_id")
-      .where({ "wi.email": normalizedEmail, "wi.status": "pending" })
-      .orderBy("wi.created_at", "desc")
-      .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
+    const rows = await queryInvites(
+      {
+        email: normalizedEmail,
+        status: "pending"
+      },
+      options,
+      { includeWorkspace: true }
+    );
 
-    return rows.map(normalizeInviteWithWorkspace).filter(Boolean);
+    return rows
+      .map(normalizeInviteWithWorkspace)
+      .filter(Boolean)
+      .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
   }
 
   async function listPendingByWorkspaceIdWithWorkspace(workspaceId, options = {}) {
@@ -81,18 +159,22 @@ function createRepository(knex) {
       return [];
     }
 
-    const client = options?.trx || knex;
-    const rows = await client("workspace_invites as wi")
-      .join("workspaces as w", "w.id", "wi.workspace_id")
-      .where({ "wi.workspace_id": normalizedWorkspaceId, "wi.status": "pending" })
-      .orderBy("wi.created_at", "desc")
-      .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
+    const rows = await queryInvites(
+      {
+        workspace: normalizedWorkspaceId,
+        status: "pending"
+      },
+      options,
+      { includeWorkspace: true }
+    );
 
-    return rows.map(normalizeInviteWithWorkspace).filter(Boolean);
+    return rows
+      .map(normalizeInviteWithWorkspace)
+      .filter(Boolean)
+      .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
   }
 
   async function insert(payload = {}, options = {}) {
-    const client = options?.trx || knex;
     const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
     const workspaceId = normalizeRecordId(source.workspaceId, { fallback: null });
     if (!workspaceId) {
@@ -109,22 +191,52 @@ function createRepository(knex) {
     };
 
     try {
-      return await resourceRuntime.create(createPayload, {
-        ...options,
-        trx: client,
-        include: "none"
-      });
+      const created = await api.resources.workspaceInvites.post(
+        {
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            {
+              email: createPayload.email,
+              roleSid: createPayload.roleSid,
+              status: createPayload.status,
+              tokenHash: createPayload.tokenHash,
+              expiresAt: createPayload.expiresAt ?? null,
+              acceptedAt: null,
+              revokedAt: null,
+              createdAt: new Date(),
+              updatedAt: new Date()
+            },
+            {
+              relationships: createInviteRelationships({
+                workspaceId: createPayload.workspaceId,
+                invitedByUserId: createPayload.invitedByUserId ?? null
+              })
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
+
+      return normalizeInviteRecord(simplifyJsonApiDocument(created));
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
       }
     }
 
-    const row = await client("workspace_invites")
-      .where({ workspace_id: createPayload.workspaceId, email: createPayload.email, status: "pending" })
-      .orderBy("id", "desc")
-      .first();
-    return normalizeInviteRecord(row);
+    const rows = await queryInvites(
+      {
+        workspace: createPayload.workspaceId,
+        email: createPayload.email,
+        status: "pending"
+      },
+      options
+    );
+
+    rows.sort((left, right) => String(right.id || "").localeCompare(String(left.id || "")));
+    return normalizeInviteRecord(rows[0] || null);
   }
 
   async function expirePendingByWorkspaceIdAndEmail(workspaceId, email, options = {}) {
@@ -133,14 +245,38 @@ function createRepository(knex) {
       return;
     }
 
-    const client = options?.trx || knex;
     const patch = normalizeInvitePatchPayload({ status: "expired" });
-    await client("workspace_invites")
-      .where({ workspace_id: normalizedWorkspaceId, email: normalizeLowerText(email), status: "pending" })
-      .update({
-        status: patch.status,
-        updated_at: nowDb()
-      });
+    const rows = await queryInvites(
+      {
+        workspace: normalizedWorkspaceId,
+        email: normalizeLowerText(email),
+        status: "pending"
+      },
+      options
+    );
+
+    for (const row of rows) {
+      if (!row?.id) {
+        continue;
+      }
+      await api.resources.workspaceInvites.patch(
+        {
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            {
+              status: patch.status,
+              updatedAt: nowDb()
+            },
+            {
+              id: row.id
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
+    }
   }
 
   async function markAcceptedById(inviteId, options = {}) {
@@ -149,16 +285,23 @@ function createRepository(knex) {
       return;
     }
 
-    await resourceRuntime.updateById(
-      normalizedInviteId,
+    await api.resources.workspaceInvites.patch(
       {
-        status: "accepted",
-        acceptedAt: new Date()
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          {
+            status: "accepted",
+            acceptedAt: new Date(),
+            updatedAt: new Date()
+          },
+          {
+            id: normalizedInviteId
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
       },
-      {
-        ...options,
-        include: "none"
-      }
+      createJsonRestContext(options?.context || null)
     );
   }
 
@@ -168,16 +311,23 @@ function createRepository(knex) {
       return;
     }
 
-    await resourceRuntime.updateById(
-      normalizedInviteId,
+    await api.resources.workspaceInvites.patch(
       {
-        status: "revoked",
-        revokedAt: new Date()
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          {
+            status: "revoked",
+            revokedAt: new Date(),
+            updatedAt: new Date()
+          },
+          {
+            id: normalizedInviteId
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
       },
-      {
-        ...options,
-        include: "none"
-      }
+      createJsonRestContext(options?.context || null)
     );
   }
 
@@ -188,11 +338,16 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    const row = await client("workspace_invites")
-      .where({ id: normalizedInviteId, workspace_id: normalizedWorkspaceId, status: "pending" })
-      .first();
-    return normalizeInviteRecord(row);
+    const rows = await queryInvites(
+      {
+        id: normalizedInviteId,
+        workspace: normalizedWorkspaceId,
+        status: "pending"
+      },
+      options
+    );
+
+    return normalizeInviteRecord(rows[0] || null);
   }
 
   return Object.freeze({