@jskit-ai/workspaces-core 0.1.14 → 0.1.16

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/workspaces-core",
-  version: "0.1.14",
+  version: "0.1.16",
   kind: "runtime",
   description: "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
   dependsOn: [
@@ -110,7 +110,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/users-core": "0.1.48"
+        "@jskit-ai/users-core": "0.1.50"
       },
       dev: {}
     },

package/package.json

@@ -1,14 +1,29 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
-    "./server/WorkspacesCoreServiceProvider": "./src/server/WorkspacesCoreServiceProvider.js"
+    "./server/WorkspacesCoreServiceProvider": "./src/server/WorkspacesCoreServiceProvider.js",
+    "./server/validators/routeParamsValidator": "./src/server/common/validators/routeParamsValidator.js",
+    "./server/support/resolveWorkspace": "./src/server/support/resolveWorkspace.js",
+    "./server/support/workspaceRouteInput": "./src/server/support/workspaceRouteInput.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": {
-    "@jskit-ai/users-core": "0.1.48"
+    "@fastify/type-provider-typebox": "^6.1.0",
+    "@jskit-ai/auth-core": "0.1.39",
+    "@jskit-ai/database-runtime": "0.1.40",
+    "@jskit-ai/http-runtime": "0.1.39",
+    "@jskit-ai/kernel": "0.1.40",
+    "@jskit-ai/users-core": "0.1.50",
+    "typebox": "^1.0.81"
   }
 }

package/src/server/WorkspacesCoreServiceProvider.js

@@ -1,5 +1,44 @@
-import { UsersWorkspacesServiceProvider } from "@jskit-ai/users-core/server/UsersWorkspacesServiceProvider";
+import { bootWorkspaceDirectoryRoutes } from "./workspaceDirectory/bootWorkspaceDirectoryRoutes.js";
+import { registerWorkspaceDirectory } from "./workspaceDirectory/registerWorkspaceDirectory.js";
+import {
+  registerWorkspacePendingInvitations
+} from "./workspacePendingInvitations/registerWorkspacePendingInvitations.js";
+import { bootWorkspacePendingInvitations } from "./workspacePendingInvitations/bootWorkspacePendingInvitations.js";
+import { registerWorkspaceMembers } from "./workspaceMembers/registerWorkspaceMembers.js";
+import { bootWorkspaceMembers } from "./workspaceMembers/bootWorkspaceMembers.js";
+import { registerWorkspaceSettings } from "./workspaceSettings/registerWorkspaceSettings.js";
+import { bootWorkspaceSettings } from "./workspaceSettings/bootWorkspaceSettings.js";
+import { registerWorkspaceRepositories } from "./registerWorkspaceRepositories.js";
+import { registerWorkspaceCore } from "./registerWorkspaceCore.js";
+import { registerWorkspaceBootstrap } from "./registerWorkspaceBootstrap.js";
 
-const WorkspacesCoreServiceProvider = UsersWorkspacesServiceProvider;
+class WorkspacesCoreServiceProvider {
+  static id = "workspaces.core";
+
+  static dependsOn = ["users.core"];
+
+  register(app) {
+    registerWorkspaceRepositories(app);
+    registerWorkspaceCore(app);
+    registerWorkspaceBootstrap(app);
+    registerWorkspaceDirectory(app);
+    registerWorkspaceMembers(app);
+    registerWorkspaceSettings(app);
+    registerWorkspacePendingInvitations(app);
+  }
+
+  async boot(app) {
+    if (app.make("workspaces.enabled") !== true) {
+      return;
+    }
+
+    bootWorkspaceDirectoryRoutes(app);
+    if (app.make("workspaces.invitations.enabled") === true) {
+      bootWorkspacePendingInvitations(app);
+    }
+    bootWorkspaceSettings(app);
+    bootWorkspaceMembers(app);
+  }
+}
 
 export { WorkspacesCoreServiceProvider };

package/src/server/common/contributors/workspaceActionContextContributor.js

@@ -0,0 +1,88 @@
+import {
+  normalizeObject,
+  requireServiceMethod
+} from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import {
+  checkRouteVisibility,
+  ROUTE_VISIBILITY_PUBLIC,
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER
+} from "@jskit-ai/kernel/shared/support/visibility";
+import { resolveActionUser } from "../support/resolveActionUser.js";
+const WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET = new Set([
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER
+]);
+
+function normalizeWorkspaceSurfaceIds(surfaceIds = []) {
+  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
+  const normalized = new Set();
+
+  for (const entry of source) {
+    const surfaceId = normalizeSurfaceId(entry);
+    if (!surfaceId) {
+      continue;
+    }
+    normalized.add(surfaceId);
+  }
+
+  return normalized;
+}
+
+function createWorkspaceActionContextContributor({ workspaceService, workspaceSurfaceIds = [] } = {}) {
+  const contributorId = "workspaces.context";
+  const workspaceSurfaceIdSet = normalizeWorkspaceSurfaceIds(workspaceSurfaceIds);
+
+  requireServiceMethod(workspaceService, "resolveWorkspaceContextForUserBySlug", contributorId);
+
+  return Object.freeze({
+    contributorId,
+    async contribute({ definition = null, input, context, request } = {}) {
+      const payload = normalizeObject(input);
+      if (!Object.hasOwn(payload, "workspaceSlug")) {
+        return {};
+      }
+
+      const actionSurfaces = Array.isArray(definition?.surfaces) ? definition.surfaces : [];
+      const hasWorkspaceActionSurface = actionSurfaces.some((surfaceId) => workspaceSurfaceIdSet.has(surfaceId));
+      const routeSurfaceId = normalizeSurfaceId(request?.routeOptions?.config?.surface);
+      const hasWorkspaceSurface = workspaceSurfaceIdSet.has(routeSurfaceId);
+      const routeVisibilityInput =
+        request && request.routeOptions && request.routeOptions.config
+          ? request.routeOptions.config.visibility
+          : ROUTE_VISIBILITY_PUBLIC;
+      const routeVisibility = checkRouteVisibility(routeVisibilityInput);
+      const hasWorkspaceRouteVisibility = WORKSPACE_VISIBILITY_ACTION_CONTEXT_SET.has(routeVisibility);
+      if (!hasWorkspaceActionSurface && !hasWorkspaceRouteVisibility && !hasWorkspaceSurface) {
+        return {};
+      }
+
+      const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(
+        resolveActionUser(context, payload),
+        payload.workspaceSlug,
+        { request }
+      );
+
+      const contribution = {
+        requestMeta: {
+          resolvedWorkspaceContext
+        }
+      };
+
+      if (!context?.workspace) {
+        contribution.workspace = resolvedWorkspaceContext.workspace;
+      }
+      if (!context?.membership) {
+        contribution.membership = resolvedWorkspaceContext.membership;
+      }
+      if (!Array.isArray(context?.permissions) || context.permissions.length < 1) {
+        contribution.permissions = resolvedWorkspaceContext.permissions;
+      }
+
+      return contribution;
+    }
+  });
+}
+
+export { createWorkspaceActionContextContributor };

package/src/server/common/contributors/workspaceAuthPolicyContextResolver.js

@@ -0,0 +1,34 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function createWorkspaceAuthPolicyContextResolver({ workspaceService } = {}) {
+  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
+    throw new Error(
+      "workspace auth policy context resolver requires workspaceService.resolveWorkspaceContextForUserBySlug()."
+    );
+  }
+
+  return async function resolveWorkspaceAuthPolicyContext({ request, actor, meta } = {}) {
+    const contextPolicy = normalizeText(meta?.contextPolicy || "none").toLowerCase() || "none";
+    const permission = normalizeText(meta?.permission);
+    if (contextPolicy === "none" && !permission) {
+      return {};
+    }
+
+    const workspaceSlug = normalizeText(request?.params?.workspaceSlug).toLowerCase();
+    if (!workspaceSlug || !actor) {
+      return {};
+    }
+
+    const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, {
+      request
+    });
+
+    return {
+      workspace: resolvedWorkspaceContext?.workspace || null,
+      membership: resolvedWorkspaceContext?.membership || null,
+      permissions: Array.isArray(resolvedWorkspaceContext?.permissions) ? resolvedWorkspaceContext.permissions : []
+    };
+  };
+}
+
+export { createWorkspaceAuthPolicyContextResolver };

package/src/server/common/contributors/workspaceRouteVisibilityResolver.js

@@ -0,0 +1,78 @@
+import { normalizeOpaqueId, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function buildVisibilityContribution({ visibility, scopeOwnerId = null, userId = null } = {}) {
+  const requiresActorScope = visibility === "workspace_user";
+  const contribution = {
+    scopeKind: requiresActorScope ? "workspace_user" : "workspace",
+    requiresActorScope
+  };
+
+  if (scopeOwnerId) {
+    contribution.scopeOwnerId = scopeOwnerId;
+  }
+  if (requiresActorScope && userId != null) {
+    contribution.userId = userId;
+  }
+
+  return contribution;
+}
+
+function createWorkspaceRouteVisibilityResolver({ workspaceService } = {}) {
+  if (!workspaceService || typeof workspaceService.resolveWorkspaceContextForUserBySlug !== "function") {
+    throw new Error("workspace route visibility resolver requires workspaceService.resolveWorkspaceContextForUserBySlug().");
+  }
+
+  return Object.freeze({
+    resolverId: "workspaces.visibility",
+    async resolve({ visibility, context, request, input } = {}) {
+      if (visibility !== "workspace" && visibility !== "workspace_user") {
+        return {};
+      }
+
+      const actor = context?.actor || request?.user || null;
+      const userId = normalizeOpaqueId(actor?.id);
+      const workspace =
+        context?.workspace || context?.requestMeta?.resolvedWorkspaceContext?.workspace || request?.workspace || null;
+      const scopeOwnerId = normalizeRecordId(workspace?.id, { fallback: null });
+      if (!scopeOwnerId) {
+        const workspaceSlug = normalizeText(input?.workspaceSlug).toLowerCase();
+
+        if (!workspaceSlug || !actor) {
+          return visibility === "workspace_user"
+            ? buildVisibilityContribution({
+                visibility,
+                userId
+              })
+            : {};
+        }
+
+        const resolvedWorkspaceContext = await workspaceService.resolveWorkspaceContextForUserBySlug(actor, workspaceSlug, {
+          request
+        });
+        const resolvedWorkspaceOwnerId = normalizeRecordId(resolvedWorkspaceContext?.workspace?.id, { fallback: null });
+        if (!resolvedWorkspaceOwnerId) {
+          return visibility === "workspace_user"
+            ? buildVisibilityContribution({
+                visibility,
+                userId
+              })
+            : {};
+        }
+
+        return buildVisibilityContribution({
+          visibility,
+          scopeOwnerId: resolvedWorkspaceOwnerId,
+          userId
+        });
+      }
+
+      return buildVisibilityContribution({
+        visibility,
+        scopeOwnerId,
+        userId
+      });
+    }
+  });
+}
+
+export { createWorkspaceRouteVisibilityResolver };

package/src/server/common/formatters/workspaceFormatter.js

@@ -0,0 +1,53 @@
+import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
+import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+function mapWorkspaceSummary(workspace, membership) {
+  return {
+    id: normalizeRecordId(workspace.id, { fallback: "" }),
+    slug: normalizeText(workspace.slug),
+    name: normalizeText(workspace.name),
+    avatarUrl: normalizeText(workspace.avatarUrl),
+    roleSid: normalizeLowerText(membership?.roleSid || "member") || "member",
+    isAccessible: normalizeLowerText(membership?.status || "active") === "active"
+  };
+}
+
+function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEnabled = true } = {}) {
+  const source = workspaceSettings && typeof workspaceSettings === "object" ? workspaceSettings : {};
+  const invitesAvailable = workspaceInvitationsEnabled === true;
+  const invitesEnabled = invitesAvailable && source.invitesEnabled !== false;
+  const themePalettes = resolveWorkspaceThemePalettes(source);
+
+  return {
+    lightPrimaryColor: themePalettes.light.color,
+    lightSecondaryColor: themePalettes.light.secondaryColor,
+    lightSurfaceColor: themePalettes.light.surfaceColor,
+    lightSurfaceVariantColor: themePalettes.light.surfaceVariantColor,
+    darkPrimaryColor: themePalettes.dark.color,
+    darkSecondaryColor: themePalettes.dark.secondaryColor,
+    darkSurfaceColor: themePalettes.dark.surfaceColor,
+    darkSurfaceVariantColor: themePalettes.dark.surfaceVariantColor,
+    invitesEnabled,
+    invitesAvailable,
+    invitesEffective: invitesAvailable && invitesEnabled
+  };
+}
+
+function mapMembershipSummary(membership, workspace) {
+  if (!membership) {
+    return null;
+  }
+
+  return {
+    workspaceId: normalizeRecordId(workspace?.id || membership.workspaceId, { fallback: "" }),
+    roleSid: normalizeLowerText(membership.roleSid || "member") || "member",
+    status: normalizeLowerText(membership.status || "active") || "active"
+  };
+}
+
+export {
+  mapMembershipSummary,
+  mapWorkspaceSettingsPublic,
+  mapWorkspaceSummary
+};

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

@@ -0,0 +1,59 @@
+import {
+  normalizeDbRecordId,
+  toInsertDateTime,
+  toNullableDateTime,
+  toIsoString,
+  createWithTransaction
+} from "@jskit-ai/database-runtime/shared";
+import { isDuplicateEntryError } from "@jskit-ai/database-runtime/shared/duplicateEntry";
+import { normalizeLowerText, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+function nowDb() {
+  return toInsertDateTime();
+}
+
+function toNullableIso(value) {
+  if (!value) {
+    return null;
+  }
+  return toIsoString(value);
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((left, right) => String(left).localeCompare(String(right)));
+}
+
+function parseJson(value, fallback = {}) {
+  if (value == null) {
+    return fallback;
+  }
+  if (typeof value === "object") {
+    return value;
+  }
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    return fallback;
+  }
+}
+
+function toDbJson(value, fallback = {}) {
+  const source = value && typeof value === "object" ? value : fallback;
+  return JSON.stringify(source);
+}
+
+export {
+  toNullableDateTime,
+  toIsoString,
+  isDuplicateEntryError,
+  normalizeText,
+  normalizeLowerText,
+  normalizeRecordId,
+  normalizeDbRecordId,
+  nowDb,
+  toNullableIso,
+  uniqueSorted,
+  parseJson,
+  toDbJson,
+  createWithTransaction
+};

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

@@ -0,0 +1,208 @@
+import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
+import {
+  normalizeLowerText,
+  normalizeDbRecordId,
+  normalizeRecordId,
+  normalizeText,
+  toIsoString,
+  toNullableIso,
+  toNullableDateTime,
+  nowDb,
+  isDuplicateEntryError,
+  createWithTransaction
+} from "./repositoryUtils.js";
+
+function mapRow(row) {
+  if (!row) {
+    return null;
+  }
+
+  return {
+    id: normalizeDbRecordId(row.id, { fallback: "" }),
+    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
+    email: normalizeLowerText(row.email),
+    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
+    status: normalizeLowerText(row.status || "pending") || "pending",
+    tokenHash: normalizeText(row.token_hash),
+    invitedByUserId: row.invited_by_user_id == null ? null : normalizeDbRecordId(row.invited_by_user_id, { fallback: null }),
+    expiresAt: toNullableIso(row.expires_at),
+    acceptedAt: toNullableIso(row.accepted_at),
+    revokedAt: toNullableIso(row.revoked_at),
+    createdAt: toIsoString(row.created_at),
+    updatedAt: toIsoString(row.updated_at),
+    workspaceSlug: row.workspace_slug ? normalizeText(row.workspace_slug) : undefined,
+    workspaceName: row.workspace_name ? normalizeText(row.workspace_name) : undefined,
+    workspaceAvatarUrl: row.workspace_avatar_url ? normalizeText(row.workspace_avatar_url) : 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 createRepository(knex) {
+  if (typeof knex !== "function") {
+    throw new TypeError("workspaceInvitesRepository requires knex.");
+  }
+  const withTransaction = createWithTransaction(knex);
+
+  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 mapRow(row);
+  }
+
+  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);
+
+    return rows.map(mapRow).filter(Boolean);
+  }
+
+  async function listPendingByWorkspaceIdWithWorkspace(workspaceId, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedWorkspaceId) {
+      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);
+
+    return rows.map(mapRow).filter(Boolean);
+  }
+
+  async function insert(payload = {}, options = {}) {
+    const client = options?.trx || knex;
+    const source = payload && typeof payload === "object" ? payload : {};
+    const workspaceId = normalizeRecordId(source.workspaceId, { fallback: null });
+    if (!workspaceId) {
+      throw new TypeError("workspaceInvitesRepository.insert requires workspaceId.");
+    }
+
+    const insertPayload = {
+      workspace_id: workspaceId,
+      email: normalizeLowerText(source.email),
+      role_sid: normalizeLowerText(source.roleSid || "member") || "member",
+      status: normalizeLowerText(source.status || "pending") || "pending",
+      token_hash: normalizeText(source.tokenHash),
+      invited_by_user_id: source.invitedByUserId == null ? null : normalizeRecordId(source.invitedByUserId, { fallback: null }),
+      expires_at: toNullableDateTime(source.expiresAt),
+      accepted_at: null,
+      revoked_at: null,
+      created_at: nowDb(),
+      updated_at: nowDb()
+    };
+
+    try {
+      const result = await client("workspace_invites").insert(insertPayload);
+      const insertedId = resolveInsertedRecordId(result, { fallback: null });
+      if (insertedId) {
+        const row = await client("workspace_invites").where({ id: insertedId }).first();
+        return mapRow(row);
+      }
+    } catch (error) {
+      if (!isDuplicateEntryError(error)) {
+        throw error;
+      }
+    }
+
+    const row = await client("workspace_invites")
+      .where({ workspace_id: insertPayload.workspace_id, email: insertPayload.email, status: "pending" })
+      .orderBy("id", "desc")
+      .first();
+    return mapRow(row);
+  }
+
+  async function expirePendingByWorkspaceIdAndEmail(workspaceId, email, options = {}) {
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedWorkspaceId) {
+      return;
+    }
+
+    const client = options?.trx || knex;
+    await client("workspace_invites")
+      .where({ workspace_id: normalizedWorkspaceId, email: normalizeLowerText(email), status: "pending" })
+      .update({
+        status: "expired",
+        updated_at: nowDb()
+      });
+  }
+
+  async function markAcceptedById(inviteId, options = {}) {
+    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
+    if (!normalizedInviteId) {
+      return;
+    }
+
+    const client = options?.trx || knex;
+    await client("workspace_invites")
+      .where({ id: normalizedInviteId })
+      .update({
+        status: "accepted",
+        accepted_at: nowDb(),
+        updated_at: nowDb()
+      });
+  }
+
+  async function revokeById(inviteId, options = {}) {
+    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
+    if (!normalizedInviteId) {
+      return;
+    }
+
+    const client = options?.trx || knex;
+    await client("workspace_invites")
+      .where({ id: normalizedInviteId })
+      .update({
+        status: "revoked",
+        revoked_at: nowDb(),
+        updated_at: nowDb()
+      });
+  }
+
+  async function findPendingByIdForWorkspace(inviteId, workspaceId, options = {}) {
+    const normalizedInviteId = normalizeRecordId(inviteId, { fallback: null });
+    const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
+    if (!normalizedInviteId || !normalizedWorkspaceId) {
+      return null;
+    }
+
+    const client = options?.trx || knex;
+    const row = await client("workspace_invites")
+      .where({ id: normalizedInviteId, workspace_id: normalizedWorkspaceId, status: "pending" })
+      .first();
+    return mapRow(row);
+  }
+
+  return Object.freeze({
+    withTransaction,
+    findPendingByTokenHash,
+    listPendingByEmail,
+    listPendingByWorkspaceIdWithWorkspace,
+    insert,
+    expirePendingByWorkspaceIdAndEmail,
+    markAcceptedById,
+    revokeById,
+    findPendingByIdForWorkspace
+  });
+}
+
+export { createRepository, mapRow };