@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/src/server/workspaceSettings/registerWorkspaceSettings.js

@@ -0,0 +1,62 @@
+import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
+import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
+import { deepFreeze } from "../common/support/deepFreeze.js";
+import { createRepository as createWorkspaceSettingsRepository } from "./workspaceSettingsRepository.js";
+import { createService as createWorkspaceSettingsService } from "./workspaceSettingsService.js";
+import { workspaceSettingsActions } from "./workspaceSettingsActions.js";
+import { createWorkspaceRoleCatalog } from "../../shared/roles.js";
+import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
+
+function resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig = {}) {
+  const defaultInvitesEnabled = appConfig?.workspaceSettings?.defaults?.invitesEnabled;
+
+  if (typeof defaultInvitesEnabled !== "boolean") {
+    throw new TypeError("users.core requires appConfig.workspaceSettings.defaults.invitesEnabled.");
+  }
+
+  return defaultInvitesEnabled;
+}
+
+function registerWorkspaceSettings(app) {
+  if (!app || typeof app.singleton !== "function" || typeof app.actions !== "function" || typeof app.service !== "function") {
+    throw new Error("registerWorkspaceSettings requires application singleton()/service()/actions().");
+  }
+
+  app.singleton("workspaceSettingsRepository", (scope) => {
+    const knex = scope.make("jskit.database.knex");
+    const appConfig = resolveAppConfig(scope);
+    return createWorkspaceSettingsRepository(knex, {
+      defaultInvitesEnabled: resolveWorkspaceSettingsDefaultInvitesEnabled(appConfig)
+    });
+  });
+
+  app.service(
+    "workspaces.settings.service",
+    (scope) =>
+      createWorkspaceSettingsService({
+        workspaceSettingsRepository: scope.make("workspaceSettingsRepository"),
+        workspaceInvitationsEnabled: scope.make("workspaces.invitations.enabled"),
+        roleCatalog: createWorkspaceRoleCatalog(resolveAppConfig(scope))
+      }),
+    {
+      events: deepFreeze({
+        updateWorkspaceSettings: createWorkspaceEntityAndBootstrapEvents({
+          workspaceEntity: "settings",
+          workspaceOperation: "updated",
+          workspaceRealtimeEvent: "workspace.settings.changed"
+        })
+      })
+    }
+  );
+
+  app.actions(
+    withActionDefaults(workspaceSettingsActions, {
+      domain: "workspace",
+      dependencies: {
+        workspaceSettingsService: "workspaces.settings.service"
+      }
+    })
+  );
+}
+
+export { registerWorkspaceSettings };

package/src/server/workspaceSettings/workspaceSettingsActions.js

@@ -0,0 +1,72 @@
+import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
+import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
+import { resolveWorkspace } from "../support/resolveWorkspace.js";
+
+const workspaceSettingsActions = Object.freeze([
+  {
+    id: "workspace.settings.read",
+    version: 1,
+    kind: "query",
+    channels: ["api", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "any",
+      permissions: ["workspace.settings.view", "workspace.settings.update"]
+    },
+    inputValidator: workspaceSlugParamsValidator,
+    outputValidator: workspaceSettingsResource.operations.view.outputValidator,
+    idempotency: "none",
+    audit: {
+      actionName: "workspace.settings.read"
+    },
+    observability: {},
+    async execute(input, context, deps) {
+      const response = await deps.workspaceSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
+        context
+      });
+
+      return response;
+    }
+  },
+  {
+    id: "workspace.settings.update",
+    version: 1,
+    kind: "command",
+    channels: ["api", "assistant_tool", "automation", "internal"],
+    surfacesFrom: "workspace",
+    permission: {
+      require: "all",
+      permissions: ["workspace.settings.update"]
+    },
+    inputValidator: [
+      workspaceSlugParamsValidator,
+      {
+        patch: workspaceSettingsResource.operations.patch.bodyValidator
+      }
+    ],
+    outputValidator: workspaceSettingsResource.operations.patch.outputValidator,
+    idempotency: "optional",
+    audit: {
+      actionName: "workspace.settings.update"
+    },
+    observability: {},
+    extensions: {
+      assistant: {
+        description: "Update workspace settings."
+      }
+    },
+    async execute(input, context, deps) {
+      const response = await deps.workspaceSettingsService.updateWorkspaceSettings(
+        resolveWorkspace(context, input),
+        input.patch,
+        {
+          context
+        }
+      );
+
+      return response;
+    }
+  }
+]);
+
+export { workspaceSettingsActions };

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -0,0 +1,154 @@
+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
+    });
+  }
+  return seed;
+}
+
+function createRepository(knex, { defaultInvitesEnabled } = {}) {
+  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 rawValue = Object.hasOwn(row, field.dbColumn)
+        ? row[field.dbColumn]
+        : 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 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);
+  }
+
+  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 });
+    if (existing) {
+      return existing;
+    }
+
+    try {
+      const insertPayload = {
+        workspace_id: normalizedWorkspaceId,
+        created_at: nowDb(),
+        updated_at: nowDb()
+      };
+      for (const field of workspaceSettingsFields) {
+        insertPayload[field.dbColumn] = seed[field.key];
+      }
+      await client("workspace_settings").insert(insertPayload);
+    } catch (error) {
+      if (!isDuplicateEntryError(error)) {
+        throw error;
+      }
+    }
+
+    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
+  }
+
+  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());
+
+    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.dbColumn] = field.normalizeInput(settingsPatch[field.key], {
+        payload: source
+      });
+    }
+
+    await client("workspace_settings").where({ workspace_id: normalizedWorkspaceId }).update({
+      ...dbPatch
+    });
+    return findByWorkspaceId(normalizedWorkspaceId, { trx: client });
+  }
+
+  return Object.freeze({
+    withTransaction,
+    findByWorkspaceId,
+    ensureForWorkspaceId,
+    updateSettingsByWorkspaceId
+  });
+}
+
+export { createRepository };

package/src/server/workspaceSettings/workspaceSettingsService.js

@@ -0,0 +1,66 @@
+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";
+import { createWorkspaceRoleCatalog, cloneWorkspaceRoleCatalog } from "../../shared/roles.js";
+
+function createService({
+  workspaceSettingsRepository,
+  workspaceInvitationsEnabled = true,
+  roleCatalog = null
+} = {}) {
+  if (!workspaceSettingsRepository) {
+    throw new Error("workspaceSettingsService requires workspaceSettingsRepository.");
+  }
+  const resolvedRoleCatalog = roleCatalog && typeof roleCatalog === "object" ? roleCatalog : createWorkspaceRoleCatalog();
+  const invitesAvailable = workspaceInvitationsEnabled === true;
+
+  async function getWorkspaceSettings(workspace, options = {}) {
+    const settingsRecord = await workspaceSettingsRepository.ensureForWorkspaceId(workspace.id, {
+      ...options,
+      workspace
+    });
+    const settings = {};
+    for (const field of workspaceSettingsFields) {
+      settings[field.key] = settingsRecord[field.key];
+    }
+    const invitesEnabled = invitesAvailable && settings.invitesEnabled !== false;
+    settings.invitesEnabled = invitesEnabled;
+    settings.invitesAvailable = invitesAvailable;
+    settings.invitesEffective = invitesAvailable && invitesEnabled;
+
+    return {
+      workspace: {
+        id: normalizeRecordId(workspace.id, { fallback: "" }),
+        slug: String(workspace.slug || ""),
+        ownerUserId: normalizeRecordId(workspace.ownerUserId, { fallback: "" })
+      },
+      settings,
+      roleCatalog: cloneWorkspaceRoleCatalog(resolvedRoleCatalog)
+    };
+  }
+
+  async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
+    const source = normalizeObjectInput(payload);
+    const settingsPatch = pickOwnProperties(source, resolveWorkspaceSettingsFieldKeys());
+
+    if (Object.keys(settingsPatch).length > 0) {
+      await workspaceSettingsRepository.updateSettingsByWorkspaceId(workspace.id, settingsPatch, {
+        ...options,
+        workspace
+      });
+    }
+
+    return getWorkspaceSettings(workspace, options);
+  }
+
+  return Object.freeze({
+    getWorkspaceSettings,
+    updateWorkspaceSettings
+  });
+}
+
+export { createService };

package/src/shared/operationMessages.js

@@ -0,0 +1,16 @@
+function createOperationMessages({
+  validationMessage = "Validation failed.",
+  apiValidationMessage = validationMessage
+} = {}) {
+  const validation = String(validationMessage || "Validation failed.");
+  const apiValidation = String(apiValidationMessage || validation || "Validation failed.");
+
+  return Object.freeze({
+    validation,
+    apiValidation
+  });
+}
+
+export {
+  createOperationMessages
+};

package/src/shared/resources/resolveGlobalArrayRegistry.js

@@ -0,0 +1,6 @@
+function resolveGlobalArrayRegistry(symbolKey) {
+  globalThis[symbolKey] = Array.isArray(globalThis[symbolKey]) ? globalThis[symbolKey] : [];
+  return globalThis[symbolKey];
+}
+
+export { resolveGlobalArrayRegistry };