@jskit-ai/workspaces-core 0.1.31 → 0.1.33

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -1,147 +1,160 @@
 import {
-  normalizeDbRecordId,
   normalizeRecordId,
-  toIsoString,
   nowDb,
   isDuplicateEntryError,
   createWithTransaction
 } from "../common/repositories/repositoryUtils.js";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
-import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
 import {
-  workspaceSettingsFields,
-  resolveWorkspaceSettingsFieldKeys
-} from "../../shared/resources/workspaceSettingsFields.js";
-
-function resolveWorkspaceSettingsSeed(workspace = {}, { defaultInvitesEnabled = true } = {}) {
-  const source = normalizeObjectInput(workspace);
-  const seed = {};
-  for (const field of workspaceSettingsFields) {
-    const rawValue = Object.hasOwn(source, field.key)
-      ? source[field.key]
-      : field.resolveDefault({
-          workspace: source,
-          defaultInvitesEnabled
-        });
-    seed[field.key] = field.normalizeOutput(rawValue, {
-      workspace: source,
-      defaultInvitesEnabled
-    });
+  createJsonApiInputRecord,
+  createJsonRestContext,
+  simplifyJsonApiDocument
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { resolveWorkspaceThemePalettes } from "../../shared/settings.js";
+
+const RESOURCE_TYPE = "workspaceSettings";
+const WORKSPACE_SETTINGS_PATCH_FIELDS = Object.freeze([
+  "lightPrimaryColor",
+  "lightSecondaryColor",
+  "lightSurfaceColor",
+  "lightSurfaceVariantColor",
+  "darkPrimaryColor",
+  "darkSecondaryColor",
+  "darkSurfaceColor",
+  "darkSurfaceVariantColor",
+  "invitesEnabled"
+]);
+
+function pickPatchFields(source = {}) {
+  const patch = {};
+
+  for (const fieldName of WORKSPACE_SETTINGS_PATCH_FIELDS) {
+    if (Object.hasOwn(source, fieldName)) {
+      patch[fieldName] = source[fieldName];
+    }
   }
-  return seed;
+
+  return patch;
+}
+
+function createDefaultWorkspaceSettingsCreatePayload(workspaceId) {
+  const palettes = resolveWorkspaceThemePalettes({});
+
+  return {
+    id: workspaceId,
+    lightPrimaryColor: palettes.light.color,
+    lightSecondaryColor: palettes.light.secondaryColor,
+    lightSurfaceColor: palettes.light.surfaceColor,
+    lightSurfaceVariantColor: palettes.light.surfaceVariantColor,
+    darkPrimaryColor: palettes.dark.color,
+    darkSecondaryColor: palettes.dark.secondaryColor,
+    darkSurfaceColor: palettes.dark.surfaceColor,
+    darkSurfaceVariantColor: palettes.dark.surfaceVariantColor,
+    invitesEnabled: true
+  };
 }
 
-function createRepository(knex, { defaultInvitesEnabled } = {}) {
+function createRepository({ api, knex } = {}) {
+  if (!api?.resources?.workspaceSettings) {
+    throw new TypeError("workspaceSettingsRepository requires json-rest-api workspaceSettings resource.");
+  }
   if (typeof knex !== "function") {
     throw new TypeError("workspaceSettingsRepository requires knex.");
   }
   const withTransaction = createWithTransaction(knex);
 
-  function mapRow(row) {
-    if (!row) {
-      return null;
-    }
-
-    const settings = {
-      workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" })
-    };
-    for (const field of workspaceSettingsFields) {
-      const column = field.repository.column;
-      const rawValue = Object.hasOwn(row, column)
-        ? row[column]
-        : field.resolveDefault({
-            defaultInvitesEnabled
-          });
-      settings[field.key] = field.normalizeOutput(rawValue, {
-        defaultInvitesEnabled
-      });
-    }
-
-    settings.createdAt = toIsoString(row.created_at);
-    settings.updatedAt = toIsoString(row.updated_at);
-    return settings;
+  async function queryFirst(filters = {}, options = {}) {
+    const result = await api.resources.workspaceSettings.query(
+      {
+        queryParams: {
+          filters
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    const rows = simplifyJsonApiDocument(result);
+    return Array.isArray(rows) ? rows[0] || null : null;
   }
 
   async function findByWorkspaceId(workspaceId, options = {}) {
-    const client = options?.trx || knex;
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
     if (!normalizedWorkspaceId) {
       return null;
     }
 
-    const row = await client("workspace_settings").where({ workspace_id: normalizedWorkspaceId }).first();
-    return mapRow(row);
+    return queryFirst({ id: normalizedWorkspaceId }, options);
   }
 
   async function ensureForWorkspaceId(workspaceId, options = {}) {
-    const client = options?.trx || knex;
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
     if (!normalizedWorkspaceId) {
       throw new TypeError("workspaceSettingsRepository.ensureForWorkspaceId requires a valid workspace id.");
     }
 
-    const seed = resolveWorkspaceSettingsSeed(options?.workspace, {
-      defaultInvitesEnabled
-    });
-    const existing = await findByWorkspaceId(normalizedWorkspaceId, { trx: client });
+    const existing = await findByWorkspaceId(normalizedWorkspaceId, options);
     if (existing) {
       return existing;
     }
 
     try {
-      const insertPayload = {
-        workspace_id: normalizedWorkspaceId,
-        created_at: nowDb(),
-        updated_at: nowDb()
-      };
-      for (const field of workspaceSettingsFields) {
-        insertPayload[field.repository.column] = seed[field.key];
-      }
-      await client("workspace_settings").insert(insertPayload);
+      await api.resources.workspaceSettings.post(
+        {
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            createDefaultWorkspaceSettingsCreatePayload(normalizedWorkspaceId),
+            {
+              id: normalizedWorkspaceId
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
+        },
+        createJsonRestContext(options?.context || null)
+      );
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
       }
     }
 
-    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
+    return findByWorkspaceId(normalizedWorkspaceId, options);
   }
 
   async function updateSettingsByWorkspaceId(workspaceId, patch = {}, options = {}) {
-    const client = options?.trx || knex;
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
     if (!normalizedWorkspaceId) {
       throw new TypeError("workspaceSettingsRepository.updateSettingsByWorkspaceId requires a valid workspace id.");
     }
 
-    const ensured = await ensureForWorkspaceId(normalizedWorkspaceId, {
-      trx: client,
-      workspace: options?.workspace
-    });
-    const source = normalizeObjectInput(patch);
-    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
+    await ensureForWorkspaceId(normalizedWorkspaceId, options);
+    const source = patch && typeof patch === "object" && !Array.isArray(patch) ? patch : {};
+    const updatePayload = pickPatchFields(source);
 
-    if (Object.keys(settingsPatch).length === 0) {
-      return ensured;
-    }
-
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-    for (const field of workspaceSettingsFields) {
-      if (!Object.hasOwn(settingsPatch, field.key)) {
-        continue;
-      }
-      dbPatch[field.repository.column] = field.normalizeInput(settingsPatch[field.key], {
-        payload: source
-      });
+    if (Object.keys(updatePayload).length < 1) {
+      return findByWorkspaceId(normalizedWorkspaceId, options);
     }
 
-    await client("workspace_settings").where({ workspace_id: normalizedWorkspaceId }).update({
-      ...dbPatch
-    });
-    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
+    await api.resources.workspaceSettings.patch(
+      {
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          {
+            ...updatePayload,
+            updatedAt: nowDb()
+          },
+          {
+            id: normalizedWorkspaceId
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    return findByWorkspaceId(normalizedWorkspaceId, options);
   }
 
   return Object.freeze({

package/src/server/workspaceSettings/workspaceSettingsService.js

@@ -2,9 +2,8 @@ import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
 import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
 import {
-  workspaceSettingsFields,
-  resolveWorkspaceSettingsFieldKeys
-} from "../../shared/resources/workspaceSettingsFields.js";
+  WORKSPACE_SETTINGS_FIELD_KEYS
+} from "../../shared/resources/workspaceSettingsResource.js";
 import { createWorkspaceRoleCatalog, cloneWorkspaceRoleCatalog } from "../../shared/roles.js";
 
 function createService({
@@ -24,8 +23,8 @@ function createService({
       workspace
     });
     const settings = {};
-    for (const field of workspaceSettingsFields) {
-      settings[field.key] = settingsRecord[field.key];
+    for (const fieldKey of WORKSPACE_SETTINGS_FIELD_KEYS) {
+      settings[fieldKey] = settingsRecord[fieldKey];
     }
     const invitesEnabled = invitesAvailable && settings.invitesEnabled !== false;
     settings.invitesEnabled = invitesEnabled;
@@ -45,7 +44,7 @@ function createService({
 
   async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
     const source = normalizeObjectInput(payload);
-    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
+    const settingsPatch = pickOwnProperties(source, WORKSPACE_SETTINGS_FIELD_KEYS);
 
     if (Object.keys(settingsPatch).length > 0) {
       await workspaceSettingsRepository.updateSettingsByWorkspaceId(workspace.id, settingsPatch, {

package/src/shared/jsonApiTransports.js

@@ -0,0 +1,79 @@
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+
+const WORKSPACES_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  requestType: "workspaces",
+  responseType: "workspaces",
+  responseKind: "record"
+});
+
+const WORKSPACES_COLLECTION_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  responseType: "workspaces",
+  responseKind: "collection"
+});
+
+const WORKSPACE_SETTINGS_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  requestType: "workspace-settings",
+  responseType: "workspace-settings",
+  responseKind: "record"
+});
+
+const WORKSPACE_ROLE_CATALOG_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  responseType: "workspace-role-catalogs",
+  responseKind: "record"
+});
+
+const WORKSPACE_MEMBERS_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  responseType: "workspace-members",
+  responseKind: "record"
+});
+
+const WORKSPACE_MEMBER_ROLE_UPDATE_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  requestType: "workspace-member-role-updates",
+  responseType: "workspace-members",
+  responseKind: "record"
+});
+
+const WORKSPACE_INVITES_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  responseType: "workspace-invites",
+  responseKind: "record"
+});
+
+const WORKSPACE_INVITE_CREATE_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  requestType: "workspace-invite-creations",
+  responseType: "workspace-invites",
+  responseKind: "record"
+});
+
+const WORKSPACE_INVITE_REDEEM_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  requestType: "workspace-invitation-decisions",
+  responseType: "workspace-invitation-decisions",
+  responseKind: "record"
+});
+
+const WORKSPACE_PENDING_INVITATIONS_TRANSPORT = deepFreeze({
+  kind: "jsonapi-resource",
+  responseType: "workspace-pending-invitations",
+  responseKind: "record"
+});
+
+export {
+  WORKSPACES_TRANSPORT,
+  WORKSPACES_COLLECTION_TRANSPORT,
+  WORKSPACE_SETTINGS_TRANSPORT,
+  WORKSPACE_ROLE_CATALOG_TRANSPORT,
+  WORKSPACE_MEMBERS_TRANSPORT,
+  WORKSPACE_MEMBER_ROLE_UPDATE_TRANSPORT,
+  WORKSPACE_INVITES_TRANSPORT,
+  WORKSPACE_INVITE_CREATE_TRANSPORT,
+  WORKSPACE_INVITE_REDEEM_TRANSPORT,
+  WORKSPACE_PENDING_INVITATIONS_TRANSPORT
+};

package/src/shared/resources/workspaceInvitesResource.js

@@ -0,0 +1,158 @@
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+
+const workspaceInvitesResource = defineCrudResource({
+  namespace: "workspaceInvites",
+  tableName: "workspace_invites",
+  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 }
+      }
+    },
+    email: {
+      type: "string",
+      required: true,
+      max: 255,
+      search: true,
+      setter: (value) => normalizeLowerText(value),
+      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: 64,
+      defaultTo: "pending",
+      search: true,
+      setter: (value) => normalizeLowerText(value),
+      operations: {
+        output: { required: true },
+        create: { required: true },
+        patch: { required: false }
+      }
+    },
+    tokenHash: {
+      type: "string",
+      required: true,
+      max: 255,
+      search: true,
+      storage: { column: "token_hash" },
+      setter: (value) => normalizeText(value),
+      operations: {
+        output: { required: true },
+        create: { required: true }
+      }
+    },
+    invitedByUserId: {
+      type: "id",
+      nullable: true,
+      belongsTo: "userProfiles",
+      as: "invitedByUser",
+      storage: { column: "invited_by_user_id" },
+      operations: {
+        output: { required: false },
+        create: { required: false }
+      }
+    },
+    expiresAt: {
+      type: "dateTime",
+      nullable: true,
+      storage: {
+        column: "expires_at",
+        writeSerializer: "datetime-utc"
+      },
+      operations: {
+        output: { required: true },
+        create: { required: false },
+        patch: { required: false }
+      }
+    },
+    acceptedAt: {
+      type: "dateTime",
+      nullable: true,
+      storage: {
+        column: "accepted_at",
+        writeSerializer: "datetime-utc"
+      },
+      operations: {
+        output: { required: true },
+        create: { required: false },
+        patch: { required: false }
+      }
+    },
+    revokedAt: {
+      type: "dateTime",
+      nullable: true,
+      storage: {
+        column: "revoked_at",
+        writeSerializer: "datetime-utc"
+      },
+      operations: {
+        output: { required: true },
+        create: { required: false },
+        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 { workspaceInvitesResource };