@jskit-ai/users-core 0.1.172 → 0.1.174

package/templates/packages/users-workspace/src/server/UsersProvider.js

@@ -1,91 +0,0 @@
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { resolveCrudSurfacePolicyFromAppConfig } from "@jskit-ai/crud-core/server/crudModuleConfig";
-import {
-  INTERNAL_JSON_REST_API,
-  addResourceIfMissing,
-  createJsonRestResourceScopeOptions
-} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { toDatabaseDateTimeUtc } from "@jskit-ai/database-runtime/shared";
-import { createRepository } from "./repository.js";
-import { createService } from "./service.js";
-import { createActions } from "./actions.js";
-import { registerRoutes } from "./registerRoutes.js";
-import { resource } from "../shared/userResource.js";
-
-const CRUD_MODULE_CONFIG = Object.freeze({
-  namespace: "users",
-  surface: "admin",
-  ownershipFilter: "public",
-  relativePath: "/users"
-});
-
-function resolveCrudPolicyFromApp(app) {
-  return resolveCrudSurfacePolicyFromAppConfig(CRUD_MODULE_CONFIG, resolveAppConfig(app), {
-    context: "UsersProvider"
-  });
-}
-
-class UsersProvider {
-  static id = "crud.users";
-
-  static startsAfter = ["json-rest-api.core", "local.main", "runtime.actions"];
-
-  register(app) {
-    const crudPolicy = resolveCrudPolicyFromApp(app);
-
-    app.singleton("repository.users", (scope) => {
-      const api = scope.make(INTERNAL_JSON_REST_API);
-      const knex = scope.make("jskit.database.knex");
-      return createRepository({
-        api,
-        knex
-      });
-    });
-
-    app.service(
-      "crud.users",
-      (scope) => {
-        return createService({
-          usersRepository: scope.make("repository.users")
-        });
-      }
-    );
-
-    app.actions(
-      withActionDefaults(
-        createActions({
-          surface: crudPolicy.surfaceId
-        }),
-        {
-          domain: "crud",
-          dependencies: {
-            usersService: "crud.users"
-          }
-        }
-      )
-    );
-  }
-
-  async boot(app) {
-    const crudPolicy = resolveCrudPolicyFromApp(app);
-    const api = app.make(INTERNAL_JSON_REST_API);
-    await addResourceIfMissing(
-      api,
-      "users",
-      createJsonRestResourceScopeOptions(resource, {
-        writeSerializers: {
-          "datetime-utc": toDatabaseDateTimeUtc
-        }
-      })
-    );
-    registerRoutes(app, {
-      routeOwnershipFilter: crudPolicy.ownershipFilter,
-      routeSurface: crudPolicy.surfaceId,
-      routeSurfaceRequiresWorkspace: crudPolicy.surfaceDefinition.requiresWorkspace === true,
-      routeRelativePath: crudPolicy.relativePath
-    });
-  }
-}
-
-export { UsersProvider };

package/templates/packages/users-workspace/src/server/actions.js

@@ -1,77 +0,0 @@
-import {
-  composeSchemaDefinitions,
-  recordIdParamsValidator
-} from "@jskit-ai/kernel/shared/validators";
-import {
-  createStandardCrudListQueryValidators,
-  createStandardCrudViewQueryValidators
-} from "@jskit-ai/crud-core/server/listQueryValidators";
-import { workspaceSlugParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
-import { resource } from "../shared/userResource.js";
-
-const authenticatedPermission = Object.freeze({
-  require: "authenticated"
-});
-
-function buildListQuery(input = {}) {
-  const query = { ...(input || {}) };
-  delete query.workspaceSlug;
-  return query;
-}
-
-function createActions({ surface } = {}) {
-  return Object.freeze([
-    {
-      id: "crud.users.list",
-      version: 1,
-      kind: "query",
-      channels: ["api", "automation", "internal"],
-      surfaces: [surface],
-      permission: authenticatedPermission,
-      input: composeSchemaDefinitions([
-        workspaceSlugParamsValidator,
-        ...createStandardCrudListQueryValidators({ resource })
-      ]),
-      output: null,
-      idempotency: "none",
-      audit: {
-        actionName: "crud.users.list"
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        return deps.usersService.queryDocuments(buildListQuery(input), {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    },
-    {
-      id: "crud.users.view",
-      version: 1,
-      kind: "query",
-      channels: ["api", "automation", "internal"],
-      surfaces: [surface],
-      permission: authenticatedPermission,
-      input: composeSchemaDefinitions([
-        workspaceSlugParamsValidator,
-        recordIdParamsValidator,
-        ...createStandardCrudViewQueryValidators()
-      ]),
-      output: null,
-      idempotency: "none",
-      audit: {
-        actionName: "crud.users.view"
-      },
-      observability: {},
-      async execute(input, context, deps) {
-        const { workspaceSlug, recordId, ...query } = input || {};
-        return deps.usersService.getDocumentById(recordId, query, {
-          context,
-          visibilityContext: context?.visibilityContext
-        });
-      }
-    }
-  ]);
-}
-
-export { createActions };

package/templates/packages/users-workspace/src/server/registerRoutes.js

@@ -1,111 +0,0 @@
-import { createJsonApiResourceRouteContract } from "@jskit-ai/http-runtime/shared/validators/jsonApiRouteTransport";
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import {
-  createCrudCursorPaginationQueryValidator,
-  listSearchQueryValidator
-} from "@jskit-ai/crud-core/server/listQueryValidators";
-import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
-import { checkRouteVisibility } from "@jskit-ai/kernel/shared/support/visibility";
-import {
-  composeSchemaDefinitions,
-  recordIdParamsValidator
-} from "@jskit-ai/kernel/shared/validators";
-import { routeParamsValidator } from "@jskit-ai/workspaces-core/server/validators/routeParamsValidator";
-import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/workspaces-core/server/support/workspaceRouteInput";
-import { resource } from "../shared/userResource.js";
-
-const listCursorPaginationQueryValidator = createCrudCursorPaginationQueryValidator({
-  orderBy: resource.defaultSort
-});
-const listRouteQueryValidator = composeSchemaDefinitions([
-  listCursorPaginationQueryValidator,
-  listSearchQueryValidator
-]);
-const RESOURCE_ROUTE_CONTRACT_TYPE = resource.namespace;
-const listRouteContract = createJsonApiResourceRouteContract({
-  type: RESOURCE_ROUTE_CONTRACT_TYPE,
-  query: listRouteQueryValidator,
-  output: resource.operations.view.output,
-  outputKind: "collection"
-});
-const viewRouteContract = createJsonApiResourceRouteContract({
-  type: RESOURCE_ROUTE_CONTRACT_TYPE,
-  output: resource.operations.view.output,
-  outputKind: "record"
-});
-const viewRouteParamsValidator = composeSchemaDefinitions([
-  routeParamsValidator,
-  recordIdParamsValidator
-]);
-
-function registerRoutes(
-  app,
-  {
-    routeOwnershipFilter = "public",
-    routeSurface = "",
-    routeSurfaceRequiresWorkspace = false,
-    routeRelativePath = ""
-  } = {}
-) {
-  const router = app.make("jskit.http.router");
-  const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
-  const routeBase = resolveScopedApiBasePath({
-    routeBase: routeSurfaceRequiresWorkspace === true ? "/w/:workspaceSlug" : "/",
-    relativePath: routeRelativePath,
-    strictParams: false
-  });
-
-  router.register(
-    "GET",
-    routeBase,
-    {
-      auth: "required",
-      surface: normalizedRouteSurface,
-      visibility: checkRouteVisibility(routeOwnershipFilter),
-      meta: {
-        tags: ["crud"],
-        summary: "List users."
-      },
-      ...listRouteContract,
-      params: routeParamsValidator
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "crud.users.list",
-        input: {
-          ...buildWorkspaceInputFromRouteParams(request.input.params),
-          ...(request.input.query || {})
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    `${routeBase}/:recordId`,
-    {
-      auth: "required",
-      surface: normalizedRouteSurface,
-      visibility: checkRouteVisibility(routeOwnershipFilter),
-      meta: {
-        tags: ["crud"],
-        summary: "View a user."
-      },
-      ...viewRouteContract,
-      params: viewRouteParamsValidator
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "crud.users.view",
-        input: {
-          ...buildWorkspaceInputFromRouteParams(request.input.params),
-          recordId: request.input.params.recordId
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { registerRoutes };

package/test/providerLifecycle.test.js

@@ -1,63 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { UsersCoreServiceProvider } from "../src/server/UsersCoreServiceProvider.js";
-import { WorkspacesCoreServiceProvider } from "../../workspaces-core/src/server/WorkspacesCoreServiceProvider.js";
-
-function createRegisterPhaseProbe() {
-  let makeCalls = 0;
-
-  const target = {
-    singleton() {
-      return proxy;
-    },
-    service() {
-      return proxy;
-    },
-    actions() {
-      return proxy;
-    },
-    instance() {
-      return proxy;
-    },
-    tag() {
-      return proxy;
-    },
-    has() {
-      return false;
-    },
-    make() {
-      makeCalls += 1;
-      return null;
-    }
-  };
-
-  const proxy = new Proxy(target, {
-    get(source, property) {
-      if (property === "makeCalls") {
-        return makeCalls;
-      }
-      if (Object.prototype.hasOwnProperty.call(source, property)) {
-        return source[property];
-      }
-      return () => proxy;
-    }
-  });
-
-  return proxy;
-}
-
-test("UsersCoreServiceProvider register phase does not resolve container services eagerly", async () => {
-  const app = createRegisterPhaseProbe();
-
-  await new UsersCoreServiceProvider().register(app);
-
-  assert.equal(app.makeCalls, 0);
-});
-
-test("WorkspacesCoreServiceProvider register phase does not resolve container services eagerly", async () => {
-  const app = createRegisterPhaseProbe();
-
-  await new WorkspacesCoreServiceProvider().register(app);
-
-  assert.equal(app.makeCalls, 0);
-});

package/test/registerCommonRepositories.test.js

@@ -1,57 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerCommonRepositories } from "../src/server/common/registerCommonRepositories.js";
-
-test("registerCommonRepositories exposes the shared users-core repositories", async () => {
-  const bindings = new Map();
-  const app = {
-    singleton(token, factory) {
-      bindings.set(token, factory);
-      return this;
-    }
-  };
-
-  registerCommonRepositories(app);
-
-  assert.equal(typeof bindings.get("internal.repository.user-settings"), "function");
-  assert.equal(typeof bindings.get("internal.repository.user-profiles"), "function");
-
-  const scope = {
-    make(token) {
-      if (token === "internal.json-rest-api") {
-        return {
-          resources: {
-            userSettings: {
-              query() {},
-              post() {},
-              patch() {}
-            },
-            userProfiles: {
-              query() {},
-              post() {},
-              patch() {}
-            }
-          }
-        };
-      }
-
-      if (token === "jskit.database.knex") {
-        return Object.assign(() => {
-          throw new Error("query execution not expected");
-        }, {
-          async transaction(work) {
-            return work({ trxId: "trx-1" });
-          }
-        });
-      }
-
-      throw new Error(`Unexpected token: ${token}`);
-    }
-  };
-
-  const settingsRepository = bindings.get("internal.repository.user-settings")(scope);
-  const profileRepository = bindings.get("internal.repository.user-profiles")(scope);
-
-  assert.equal(typeof settingsRepository.findByUserId, "function");
-  assert.equal(typeof profileRepository.findById, "function");
-});

package/test/registerServiceRealtimeEvents.test.js

@@ -1,57 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerAccountProfile } from "../src/server/accountProfile/registerAccountProfile.js";
-import { registerAccountPreferences } from "../src/server/accountPreferences/registerAccountPreferences.js";
-import { registerAccountNotifications } from "../src/server/accountNotifications/registerAccountNotifications.js";
-
-function createAppDouble() {
-  const serviceCalls = [];
-
-  return {
-    serviceCalls,
-    app: {
-      singleton() {
-        return this;
-      },
-      service(token, factory, metadata) {
-        serviceCalls.push({
-          token,
-          factory,
-          metadata
-        });
-        return this;
-      },
-      actions() {
-        return this;
-      }
-    }
-  };
-}
-
-function findServiceCall(serviceCalls, token) {
-  return serviceCalls.find((entry) => entry.token === token) || null;
-}
-
-test("account register functions publish account.settings.changed for update operations", () => {
-  const profileApp = createAppDouble();
-  registerAccountProfile(profileApp.app);
-  const profile = findServiceCall(profileApp.serviceCalls, "users.accountProfile.service");
-  assert.equal(profile?.metadata?.events?.updateProfile?.[0]?.realtime?.event, "account.settings.changed");
-  assert.equal(profile?.metadata?.events?.updateProfile?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(profile?.metadata?.events?.uploadAvatar?.[0]?.realtime?.event, "account.settings.changed");
-  assert.equal(profile?.metadata?.events?.uploadAvatar?.[1]?.realtime?.event, "users.bootstrap.changed");
-  assert.equal(profile?.metadata?.events?.deleteAvatar?.[0]?.realtime?.event, "account.settings.changed");
-  assert.equal(profile?.metadata?.events?.deleteAvatar?.[1]?.realtime?.event, "users.bootstrap.changed");
-
-  const preferencesApp = createAppDouble();
-  registerAccountPreferences(preferencesApp.app);
-  const preferences = findServiceCall(preferencesApp.serviceCalls, "users.accountPreferences.service");
-  assert.equal(preferences?.metadata?.events?.updatePreferences?.[0]?.realtime?.event, "account.settings.changed");
-  assert.equal(preferences?.metadata?.events?.updatePreferences?.[1]?.realtime?.event, "users.bootstrap.changed");
-
-  const notificationsApp = createAppDouble();
-  registerAccountNotifications(notificationsApp.app);
-  const notifications = findServiceCall(notificationsApp.serviceCalls, "users.accountNotifications.service");
-  assert.equal(notifications?.metadata?.events?.updateNotifications?.[0]?.realtime?.event, "account.settings.changed");
-  assert.equal(notifications?.metadata?.events?.updateNotifications?.[1]?.realtime?.event, "users.bootstrap.changed");
-});

package/test/registerUsersCore.test.js

@@ -1,53 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerUsersCore } from "../src/server/registerUsersCore.js";
-
-test("registerUsersCore only binds users-core singletons", () => {
-  const singletonTokens = [];
-  const app = {
-    has() {
-      return false;
-    },
-    singleton(token) {
-      singletonTokens.push(String(token || ""));
-      return this;
-    }
-  };
-
-  registerUsersCore(app);
-
-  assert.deepEqual(singletonTokens.sort(), [
-    "auth.profile.projector",
-    "users.profile.sync.service"
-  ]);
-});
-
-test("registerUsersCore still works when action runtime has not installed actionSurfaceSource yet", () => {
-  const app = {
-    has() {
-      return false;
-    },
-    singleton() {
-      return this;
-    }
-  };
-
-  assert.doesNotThrow(() => registerUsersCore(app));
-});
-
-test("registerUsersCore preserves an existing auth profile projector", () => {
-  const singletonTokens = [];
-  const app = {
-    has(token) {
-      return token === "auth.profile.projector";
-    },
-    singleton(token) {
-      singletonTokens.push(String(token || ""));
-      return this;
-    }
-  };
-
-  registerUsersCore(app);
-
-  assert.deepEqual(singletonTokens, ["users.profile.sync.service"]);
-});