@jskit-ai/users-core 0.1.172 → 0.1.173

package/src/server/profileSyncLifecycleContributorRegistry.js

@@ -1,56 +0,0 @@
-import { registerTaggedSingleton, resolveTaggedEntries } from "@jskit-ai/kernel/server/registries";
-
-const PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG = "jskit.users.profileSync.lifecycleContributors";
-
-function normalizeProfileSyncLifecycleContributor(entry) {
-  if (typeof entry === "function") {
-    return Object.freeze({
-      contributorId: String(entry.name || "anonymous"),
-      order: 0,
-      afterIdentityProfileSynced: entry
-    });
-  }
-
-  if (!entry || typeof entry !== "object" || typeof entry.afterIdentityProfileSynced !== "function") {
-    return null;
-  }
-
-  const contributorId = String(entry.contributorId || "anonymous");
-  const order = Number.isFinite(entry.order) ? Number(entry.order) : 0;
-
-  return Object.freeze({
-    ...entry,
-    contributorId,
-    order,
-    afterIdentityProfileSynced: entry.afterIdentityProfileSynced
-  });
-}
-
-function registerProfileSyncLifecycleContributor(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG, {
-    context: "registerProfileSyncLifecycleContributor"
-  });
-}
-
-function resolveProfileSyncLifecycleContributors(scope) {
-  return resolveTaggedEntries(scope, PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG)
-    .map((entry, index) => ({
-      contributor: normalizeProfileSyncLifecycleContributor(entry),
-      index
-    }))
-    .filter((entry) => Boolean(entry.contributor))
-    .sort((left, right) => {
-      if (left.contributor.order !== right.contributor.order) {
-        return left.contributor.order - right.contributor.order;
-      }
-
-      return left.index - right.index;
-    })
-    .map((entry) => entry.contributor);
-}
-
-export {
-  PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG,
-  registerProfileSyncLifecycleContributor,
-  resolveProfileSyncLifecycleContributors
-};

package/src/server/registerUsersBootstrap.js

@@ -1,20 +0,0 @@
-import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { createUsersBootstrapContributor } from "./usersBootstrapContributor.js";
-
-function registerUsersBootstrap(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerUsersBootstrap requires application singleton().");
-  }
-
-  registerBootstrapPayloadContributor(app, "users.core.bootstrap.payloadContributor", (scope) => {
-    return createUsersBootstrapContributor({
-      userProfilesRepository: scope.make("internal.repository.user-profiles"),
-      userSettingsRepository: scope.make("internal.repository.user-settings"),
-      appConfig: resolveAppConfig(scope),
-      authService: scope.make("authService")
-    });
-  });
-}
-
-export { registerUsersBootstrap };

package/src/server/registerUsersCore.js

@@ -1,22 +0,0 @@
-import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
-import { resolveProfileSyncLifecycleContributors } from "./profileSyncLifecycleContributorRegistry.js";
-
-function registerUsersCore(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.has !== "function") {
-    throw new Error("registerUsersCore requires application singleton()/has().");
-  }
-
-  app.singleton("users.profile.sync.service", (scope) => {
-    return createAuthProfileSyncService({
-      userProfilesRepository: scope.make("internal.repository.user-profiles"),
-      userSettingsRepository: scope.make("internal.repository.user-settings"),
-      lifecycleContributors: resolveProfileSyncLifecycleContributors(scope)
-    });
-  });
-
-  if (!app.has("auth.profile.projector")) {
-    app.singleton("auth.profile.projector", (scope) => scope.make("users.profile.sync.service"));
-  }
-}
-
-export { registerUsersCore };

package/templates/packages/users/package.json

@@ -1,82 +0,0 @@
-{
-  "name": "@local/users",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "exports": {
-    "./shared": "./src/shared/index.js"
-  },
-  "description": "App-local CRUD package (users).",
-  "jskit": {
-    "kind": "runtime",
-    "capabilities": {
-      "provides": [
-        "crud.users"
-      ],
-      "requires": [
-        "runtime.actions",
-        "runtime.database",
-        "auth.policy",
-        "json-rest-api.core"
-      ]
-    },
-    "runtime": {
-      "server": {
-        "providers": [
-          {
-            "entrypoint": "src/server/UsersProvider.js",
-            "export": "UsersProvider"
-          }
-        ]
-      }
-    },
-    "metadata": {
-      "jskit": {
-        "scaffoldShape": "users-core-crud-v1",
-        "tableOwnership": {
-          "tables": [
-            {
-              "tableName": "users",
-              "provenance": "users-core-template",
-              "ownerKind": "baseline-crud"
-            }
-          ]
-        }
-      },
-      "apiSummary": {
-        "surfaces": [
-          {
-            "subpath": "./shared",
-            "summary": "App-local CRUD shared resource."
-          }
-        ],
-        "containerTokens": {
-          "server": [
-            "repository.users",
-            "crud.users"
-          ]
-        }
-      }
-    },
-    "mutations": {
-      "dependencies": {
-        "runtime": {},
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": []
-    }
-  },
-  "dependencies": {
-    "@jskit-ai/auth-core": "0.1.157",
-    "@jskit-ai/crud-core": "0.1.170",
-    "@jskit-ai/database-runtime": "0.1.159",
-    "@jskit-ai/http-runtime": "0.1.157",
-    "@jskit-ai/json-rest-api-core": "0.1.103",
-    "@jskit-ai/resource-crud-core": "0.1.101",
-    "@jskit-ai/users-core": "0.1.172"
-  }
-}

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

@@ -1,90 +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: "home",
-  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,
-      routeRelativePath: crudPolicy.relativePath
-    });
-  }
-}
-
-export { UsersProvider };

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

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

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

@@ -1,101 +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 { 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"
-});
-
-function registerRoutes(
-  app,
-  {
-    routeOwnershipFilter = "public",
-    routeSurface = "",
-    routeRelativePath = ""
-  } = {}
-) {
-  const router = app.make("jskit.http.router");
-  const normalizedRouteSurface = normalizeSurfaceId(routeSurface);
-  const routeBase = resolveScopedApiBasePath({
-    routeBase: "/",
-    relativePath: routeRelativePath,
-    strictParams: false
-  });
-
-  router.register(
-    "GET",
-    routeBase,
-    {
-      auth: "required",
-      surface: normalizedRouteSurface,
-      visibility: checkRouteVisibility(routeOwnershipFilter),
-      meta: {
-        tags: ["crud"],
-        summary: "List users."
-      },
-      ...listRouteContract
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "crud.users.list",
-        input: {
-          ...(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: recordIdParamsValidator
-    },
-    async function (request, reply) {
-      const response = await request.executeAction({
-        actionId: "crud.users.view",
-        input: {
-          recordId: request.input.params.recordId
-        }
-      });
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { registerRoutes };

package/templates/packages/users/src/server/repository.js

@@ -1,51 +0,0 @@
-import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
-import {
-  buildJsonRestQueryParams,
-  createJsonRestContext,
-  returnBadRequestWhenJsonRestFieldsetInvalid,
-  returnNullWhenJsonRestResourceMissing
-} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
-import { resource } from "../shared/userResource.js";
-
-const RESOURCE_TYPE = resource.namespace;
-
-function createRepository({ api, knex } = {}) {
-  const withTransaction = createWithTransaction(knex);
-
-  async function queryDocuments(query = {}, options = {}) {
-    return returnBadRequestWhenJsonRestFieldsetInvalid(() =>
-      api.resources.users.query(
-        {
-          queryParams: buildJsonRestQueryParams(RESOURCE_TYPE, query),
-          transaction: options?.trx || null,
-          simplified: false
-        },
-        createJsonRestContext(options?.context || null)
-      )
-    );
-  }
-
-  async function getDocumentById(recordId, query = {}, options = {}) {
-    return returnBadRequestWhenJsonRestFieldsetInvalid(() =>
-      returnNullWhenJsonRestResourceMissing(() =>
-        api.resources.users.get(
-          {
-            id: recordId,
-            queryParams: buildJsonRestQueryParams(RESOURCE_TYPE, query),
-            transaction: options?.trx || null,
-            simplified: false
-          },
-          createJsonRestContext(options?.context || null)
-        )
-      )
-    );
-  }
-
-  return Object.freeze({
-    withTransaction,
-    queryDocuments,
-    getDocumentById
-  });
-}
-
-export { createRepository };

package/templates/packages/users/src/server/service.js

@@ -1,32 +0,0 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { returnJsonApiDocument } from "@jskit-ai/http-runtime/shared";
-
-function return404IfNotFound(document = null) {
-  if (!document) {
-    throw new AppError(404, "Document not found.");
-  }
-  return document;
-}
-
-function createService({ usersRepository } = {}) {
-  if (!usersRepository) {
-    throw new TypeError("createService requires usersRepository.");
-  }
-
-  return Object.freeze({
-    async queryDocuments(query = {}, options = {}) {
-      return returnJsonApiDocument(await usersRepository.queryDocuments(query, {
-        trx: options?.trx || null,
-        context: options?.context || null
-      }));
-    },
-    async getDocumentById(recordId, query = {}, options = {}) {
-      return returnJsonApiDocument(return404IfNotFound(await usersRepository.getDocumentById(recordId, query, {
-        trx: options?.trx || null,
-        context: options?.context || null
-      })));
-    }
-  });
-}
-
-export { createService };

package/templates/packages/users-workspace/package.json

@@ -1,83 +0,0 @@
-{
-  "name": "@local/users",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "exports": {
-    "./shared": "./src/shared/index.js"
-  },
-  "description": "App-local CRUD package (users).",
-  "jskit": {
-    "kind": "runtime",
-    "capabilities": {
-      "provides": [
-        "crud.users"
-      ],
-      "requires": [
-        "runtime.actions",
-        "runtime.database",
-        "auth.policy",
-        "json-rest-api.core"
-      ]
-    },
-    "runtime": {
-      "server": {
-        "providers": [
-          {
-            "entrypoint": "src/server/UsersProvider.js",
-            "export": "UsersProvider"
-          }
-        ]
-      }
-    },
-    "metadata": {
-      "jskit": {
-        "scaffoldShape": "users-core-crud-v1",
-        "tableOwnership": {
-          "tables": [
-            {
-              "tableName": "users",
-              "provenance": "users-core-template",
-              "ownerKind": "baseline-crud"
-            }
-          ]
-        }
-      },
-      "apiSummary": {
-        "surfaces": [
-          {
-            "subpath": "./shared",
-            "summary": "App-local CRUD shared resource."
-          }
-        ],
-        "containerTokens": {
-          "server": [
-            "repository.users",
-            "crud.users"
-          ]
-        }
-      }
-    },
-    "mutations": {
-      "dependencies": {
-        "runtime": {},
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": []
-    }
-  },
-  "dependencies": {
-    "@jskit-ai/auth-core": "0.1.157",
-    "@jskit-ai/crud-core": "0.1.170",
-    "@jskit-ai/database-runtime": "0.1.159",
-    "@jskit-ai/http-runtime": "0.1.157",
-    "@jskit-ai/json-rest-api-core": "0.1.103",
-    "@jskit-ai/resource-crud-core": "0.1.101",
-    "@jskit-ai/users-core": "0.1.172",
-    "@jskit-ai/workspaces-core": "0.1.137"
-  }
-}