@jskit-ai/workspaces-core 0.1.91 → 0.1.92

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/workspaces-core",
-  version: "0.1.91",
+  version: "0.1.92",
   kind: "runtime",
   description: "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
   dependsOn: [
@@ -147,10 +147,10 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/json-rest-api-core": "0.1.60",
-        "@jskit-ai/resource-core": "0.1.60",
-        "@jskit-ai/resource-crud-core": "0.1.60",
-        "@jskit-ai/users-core": "0.1.125"
+        "@jskit-ai/json-rest-api-core": "0.1.61",
+        "@jskit-ai/resource-core": "0.1.61",
+        "@jskit-ai/resource-crud-core": "0.1.61",
+        "@jskit-ai/users-core": "0.1.126"
       },
       dev: {}
     },

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.91",
+  "version": "0.1.92",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
     "./server/WorkspacesCoreServiceProvider": "./src/server/WorkspacesCoreServiceProvider.js",
-    "./server/previewWorkspaceProvisioning": "./src/server/previewWorkspaceProvisioning.js",
     "./server/validators/routeParamsValidator": "./src/server/common/validators/routeParamsValidator.js",
     "./server/support/workspaceRouteInput": "./src/server/support/workspaceRouteInput.js",
     "./shared/jsonApiTransports": "./src/shared/jsonApiTransports.js",
@@ -18,14 +17,14 @@
     "./shared/resources/workspaceSettingsResource": "./src/shared/resources/workspaceSettingsResource.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.114",
-    "@jskit-ai/database-runtime": "0.1.115",
-    "@jskit-ai/http-runtime": "0.1.115",
-    "@jskit-ai/json-rest-api-core": "0.1.60",
-    "@jskit-ai/kernel": "0.1.116",
-    "@jskit-ai/resource-crud-core": "0.1.60",
-    "@jskit-ai/resource-core": "0.1.60",
-    "@jskit-ai/users-core": "0.1.125",
+    "@jskit-ai/auth-core": "0.1.115",
+    "@jskit-ai/database-runtime": "0.1.116",
+    "@jskit-ai/http-runtime": "0.1.116",
+    "@jskit-ai/json-rest-api-core": "0.1.61",
+    "@jskit-ai/kernel": "0.1.117",
+    "@jskit-ai/resource-crud-core": "0.1.61",
+    "@jskit-ai/resource-core": "0.1.61",
+    "@jskit-ai/users-core": "0.1.126",
     "json-rest-schema": "1.x.x"
   }
 }

package/test/exportsContract.test.js

@@ -15,7 +15,6 @@ test("workspaces-core exports are explicit and aligned with production usage", (
     packageId: "@jskit-ai/workspaces-core",
     requiredExports: [
       "./server/WorkspacesCoreServiceProvider",
-      "./server/previewWorkspaceProvisioning",
       "./server/validators/routeParamsValidator",
       "./server/support/workspaceRouteInput",
       "./shared/resources/workspaceResource",

package/src/server/previewWorkspaceProvisioning.js

@@ -1,227 +0,0 @@
-import { normalizeTenancyMode, TENANCY_MODE_NONE, TENANCY_MODE_PERSONAL } from "../shared/tenancyMode.js";
-import { resolveTenancyProfile } from "../shared/tenancyProfile.js";
-import { OWNER_ROLE_ID } from "../shared/roles.js";
-import { resolveWorkspaceThemePalettes } from "../shared/settings.js";
-
-const WORKSPACE_SLUG_MAX_LENGTH = 48;
-
-function normalizeText(value = "") {
-  return String(value || "").trim();
-}
-
-function normalizeLowerText(value = "") {
-  return normalizeText(value).toLowerCase();
-}
-
-function workspaceSlugPart(value = "") {
-  const normalized = normalizeLowerText(value)
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, WORKSPACE_SLUG_MAX_LENGTH);
-  return normalized || "workspace";
-}
-
-function usernameBaseFromEmail(email = "") {
-  const normalizedEmail = normalizeLowerText(email);
-  const localPart = normalizedEmail.includes("@") ? normalizedEmail.split("@")[0] : normalizedEmail;
-  return workspaceSlugPart(localPart) || "user";
-}
-
-function buildWorkspaceBaseSlug(profile = {}) {
-  return workspaceSlugPart(profile.username || profile.displayName || usernameBaseFromEmail(profile.email));
-}
-
-function buildWorkspaceName(profile = {}) {
-  const displayName = normalizeText(profile.displayName);
-  if (displayName) {
-    return `${displayName}'s Workspace`;
-  }
-  const email = normalizeLowerText(profile.email);
-  return email ? `${email}'s Workspace` : "Workspace";
-}
-
-function buildWorkspaceSlugCandidate(baseSlug = "", suffix = 0) {
-  const base = workspaceSlugPart(baseSlug);
-  if (suffix < 1) {
-    return base;
-  }
-  const suffixText = `-${suffix + 1}`;
-  return `${base.slice(0, WORKSPACE_SLUG_MAX_LENGTH - suffixText.length)}${suffixText}`;
-}
-
-function isDuplicateError(error) {
-  return (
-    ["23505", "ER_DUP_ENTRY", "SQLITE_CONSTRAINT", "SQLITE_CONSTRAINT_UNIQUE"].includes(String(error?.code || "")) ||
-    Number(error?.errno) === 1062
-  );
-}
-
-function normalizeWorkspaceResult(workspace = null) {
-  if (!workspace) {
-    return null;
-  }
-  return {
-    id: normalizeText(workspace.id),
-    slug: normalizeLowerText(workspace.slug)
-  };
-}
-
-async function resolveUniqueWorkspaceSlug(db, baseSlug = "", { excludeWorkspaceId = "" } = {}) {
-  const normalizedExcludeWorkspaceId = normalizeText(excludeWorkspaceId);
-  for (let suffix = 0; suffix < 1000; suffix += 1) {
-    const candidate = buildWorkspaceSlugCandidate(baseSlug, suffix);
-    const existing = await db("workspaces")
-      .where({ slug: candidate })
-      .first();
-    if (!existing || normalizeText(existing.id) === normalizedExcludeWorkspaceId) {
-      return candidate;
-    }
-  }
-  throw new Error("Unable to generate unique preview workspace slug.");
-}
-
-async function hasWorkspaceTables(db) {
-  return (
-    (await db.schema.hasTable("workspaces")) &&
-    (await db.schema.hasTable("workspace_memberships")) &&
-    (await db.schema.hasTable("workspace_settings"))
-  );
-}
-
-async function findPreviewWorkspace(db, user = {}, { isPersonal = true } = {}) {
-  return db("workspaces")
-    .where({
-      owner_user_id: user.id,
-      is_personal: isPersonal
-    })
-    .orderBy("id", "asc")
-    .first();
-}
-
-async function ensureWorkspaceSettings(db, workspace = {}) {
-  const existing = await db("workspace_settings")
-    .where({ workspace_id: workspace.id })
-    .first();
-  if (existing) {
-    return false;
-  }
-
-  const palettes = resolveWorkspaceThemePalettes({});
-  try {
-    await db("workspace_settings").insert({
-      workspace_id: workspace.id,
-      light_primary_color: palettes.light.color,
-      light_secondary_color: palettes.light.secondaryColor,
-      light_surface_color: palettes.light.surfaceColor,
-      light_surface_variant_color: palettes.light.surfaceVariantColor,
-      dark_primary_color: palettes.dark.color,
-      dark_secondary_color: palettes.dark.secondaryColor,
-      dark_surface_color: palettes.dark.surfaceColor,
-      dark_surface_variant_color: palettes.dark.surfaceVariantColor,
-      invites_enabled: true
-    });
-  } catch (error) {
-    if (!isDuplicateError(error)) {
-      throw error;
-    }
-  }
-  return true;
-}
-
-async function ensureOwnerMembership(db, workspace = {}, user = {}) {
-  const existing = await db("workspace_memberships")
-    .where({
-      workspace_id: workspace.id,
-      user_id: user.id
-    })
-    .first();
-  if (existing) {
-    if (existing.role_sid !== OWNER_ROLE_ID || existing.status !== "active") {
-      await db("workspace_memberships")
-        .where({ id: existing.id })
-        .update({
-          role_sid: OWNER_ROLE_ID,
-          status: "active",
-          updated_at: new Date()
-        });
-      return true;
-    }
-    return false;
-  }
-
-  try {
-    await db("workspace_memberships").insert({
-      workspace_id: workspace.id,
-      user_id: user.id,
-      role_sid: OWNER_ROLE_ID,
-      status: "active"
-    });
-  } catch (error) {
-    if (!isDuplicateError(error)) {
-      throw error;
-    }
-  }
-  return true;
-}
-
-async function ensurePreviewWorkspace(db, user = {}, profile = {}, { appConfig = {}, tenancyMode = "" } = {}) {
-  if (!db || typeof db !== "function" || !db.schema || typeof db.schema.hasTable !== "function") {
-    throw new TypeError("ensurePreviewWorkspace requires a Knex database instance.");
-  }
-
-  const resolvedTenancyMode = normalizeTenancyMode(tenancyMode || resolveTenancyProfile(appConfig).mode);
-  if (resolvedTenancyMode === TENANCY_MODE_NONE) {
-    return {
-      workspace: null,
-      skipped: "workspace tenancy is disabled"
-    };
-  }
-
-  if (!(await hasWorkspaceTables(db))) {
-    return {
-      workspace: null,
-      skipped: "workspace tables were not found"
-    };
-  }
-
-  const isPersonal = resolvedTenancyMode === TENANCY_MODE_PERSONAL;
-  let workspace = await findPreviewWorkspace(db, user, { isPersonal });
-  if (!workspace) {
-    const slug = await resolveUniqueWorkspaceSlug(db, buildWorkspaceBaseSlug(profile));
-    try {
-      await db("workspaces").insert({
-        avatar_url: "",
-        is_personal: isPersonal,
-        name: buildWorkspaceName(profile),
-        owner_user_id: user.id,
-        slug
-      });
-    } catch (error) {
-      if (!isDuplicateError(error)) {
-        throw error;
-      }
-    }
-    workspace = await db("workspaces")
-      .where({ slug })
-      .first();
-  }
-
-  if (!workspace) {
-    throw new Error("Preview workspace could not be inserted or found.");
-  }
-
-  await ensureOwnerMembership(db, workspace, user);
-  await ensureWorkspaceSettings(db, workspace);
-
-  return {
-    workspace: normalizeWorkspaceResult(workspace),
-    skipped: ""
-  };
-}
-
-export {
-  buildWorkspaceBaseSlug,
-  buildWorkspaceName,
-  ensurePreviewWorkspace,
-  normalizeWorkspaceResult
-};

package/test/previewWorkspaceProvisioning.test.js

@@ -1,149 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { ensurePreviewWorkspace } from "../src/server/previewWorkspaceProvisioning.js";
-
-function matches(row = {}, criteria = {}) {
-  return Object.entries(criteria).every(([key, value]) => row[key] === value);
-}
-
-function createMemoryDb(initialTables = {}) {
-  const tables = {};
-  for (const [tableName, rows] of Object.entries(initialTables)) {
-    tables[tableName] = rows.map((row) => ({ ...row }));
-  }
-
-  function db(tableName) {
-    const rows = tables[tableName];
-    if (!rows) {
-      throw new Error(`Unknown table: ${tableName}`);
-    }
-    let criteria = {};
-    let order = null;
-
-    return {
-      where(nextCriteria = {}) {
-        criteria = { ...criteria, ...nextCriteria };
-        return this;
-      },
-      orderBy(column, direction = "asc") {
-        order = { column, direction };
-        return this;
-      },
-      async first() {
-        const found = rows.filter((row) => matches(row, criteria));
-        if (order) {
-          found.sort((left, right) => {
-            const leftValue = Number(left[order.column]);
-            const rightValue = Number(right[order.column]);
-            const delta = Number.isFinite(leftValue) && Number.isFinite(rightValue)
-              ? leftValue - rightValue
-              : String(left[order.column] || "").localeCompare(String(right[order.column] || ""));
-            return order.direction === "desc" ? delta * -1 : delta;
-          });
-        }
-        return found[0] || null;
-      },
-      async insert(record = {}) {
-        rows.push({
-          id: record.id || String(rows.length + 1),
-          ...record
-        });
-      },
-      async update(patch = {}) {
-        for (const row of rows.filter((entry) => matches(entry, criteria))) {
-          Object.assign(row, patch);
-        }
-      }
-    };
-  }
-
-  db.schema = {
-    async hasTable(tableName) {
-      return Object.hasOwn(tables, tableName);
-    }
-  };
-  db.tables = tables;
-  return db;
-}
-
-test("ensurePreviewWorkspace creates a personal workspace, owner membership, and settings", async () => {
-  const db = createMemoryDb({
-    workspaces: [],
-    workspace_memberships: [],
-    workspace_settings: []
-  });
-
-  const result = await ensurePreviewWorkspace(
-    db,
-    { id: "7" },
-    { email: "preview@example.test", username: "preview", displayName: "Preview User" },
-    { appConfig: { tenancyMode: "personal" } }
-  );
-
-  assert.equal(result.skipped, "");
-  assert.deepEqual(result.workspace, {
-    id: "1",
-    slug: "preview"
-  });
-  assert.equal(db.tables.workspaces[0].is_personal, true);
-  assert.equal(db.tables.workspace_memberships[0].role_sid, "owner");
-  assert.equal(db.tables.workspace_memberships[0].status, "active");
-  assert.equal(db.tables.workspace_settings[0].light_primary_color, "#1867C0");
-});
-
-test("ensurePreviewWorkspace repairs an existing owner membership", async () => {
-  const db = createMemoryDb({
-    workspaces: [
-      {
-        id: "3",
-        slug: "preview",
-        owner_user_id: "7",
-        is_personal: true,
-        name: "Preview",
-        avatar_url: ""
-      }
-    ],
-    workspace_memberships: [
-      {
-        id: "9",
-        workspace_id: "3",
-        user_id: "7",
-        role_sid: "member",
-        status: "inactive"
-      }
-    ],
-    workspace_settings: []
-  });
-
-  const result = await ensurePreviewWorkspace(
-    db,
-    { id: "7" },
-    { email: "preview@example.test", username: "preview" },
-    { appConfig: { tenancyMode: "personal" } }
-  );
-
-  assert.equal(result.workspace.id, "3");
-  assert.equal(db.tables.workspace_memberships[0].role_sid, "owner");
-  assert.equal(db.tables.workspace_memberships[0].status, "active");
-  assert.equal(db.tables.workspace_settings.length, 1);
-});
-
-test("ensurePreviewWorkspace skips when workspace tenancy is disabled", async () => {
-  const db = createMemoryDb({
-    workspaces: [],
-    workspace_memberships: [],
-    workspace_settings: []
-  });
-
-  const result = await ensurePreviewWorkspace(
-    db,
-    { id: "7" },
-    { email: "preview@example.test" },
-    { appConfig: { tenancyMode: "none" } }
-  );
-
-  assert.deepEqual(result, {
-    workspace: null,
-    skipped: "workspace tenancy is disabled"
-  });
-});