@jskit-ai/users-core 0.1.64 → 0.1.66

package/test/usersBootstrapContributor.test.js

@@ -97,7 +97,7 @@ test("users bootstrap contributor exposes the generic authenticated bootstrap pa
     }
   ]);
   assert.equal(payload.session.oauthDefaultProvider, "google");
-  assert.deepEqual(payload.userSettings, {});
+  assert.deepEqual(payload.userSettings, createUserSettings());
   assert.equal(payload.requestMeta.hasRequest, true);
 });
 
@@ -152,3 +152,42 @@ test("users bootstrap contributor emits anonymous bootstrap payload without work
   });
   assert.equal(payload.userSettings, null);
 });
+
+test("users bootstrap contributor uses shared boolean normalization for app feature flags", async () => {
+  const contributor = createUsersBootstrapContributor({
+    userProfilesRepository: {
+      async findById() {
+        return null;
+      }
+    },
+    userSettingsRepository: {
+      async ensureForUserId() {
+        return createUserSettings();
+      }
+    },
+    appConfig: {
+      assistantEnabled: "yes",
+      socialEnabled: 0,
+      socialFederationEnabled: "no"
+    }
+  });
+
+  const payload = await contributor.contribute({
+    request: {
+      async executeAction() {
+        return {
+          authenticated: false
+        };
+      }
+    },
+    payload: {},
+    reply: {}
+  });
+
+  assert.deepEqual(payload.app.features, {
+    assistantEnabled: true,
+    assistantRequiredPermission: "",
+    socialEnabled: false,
+    socialFederationEnabled: false
+  });
+});

package/test/usersPackageScaffoldContract.test.js

@@ -4,6 +4,8 @@ import path from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 import descriptor from "../package.descriptor.mjs";
+import crudCorePackage from "../../crud-core/package.json" with { type: "json" };
+import resourceCrudCorePackage from "../../resource-crud-core/package.json" with { type: "json" };
 
 const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(TEST_DIRECTORY, "..");
@@ -14,7 +16,11 @@ function readFileMutationById(id) {
 
 test("users-core installs the app-local users package scaffold", () => {
   assert.equal(descriptor.mutations.dependencies.runtime["@local/users"], "file:packages/users");
-  assert.equal(descriptor.mutations.dependencies.runtime["@jskit-ai/crud-core"], "0.1.54");
+  assert.equal(descriptor.mutations.dependencies.runtime["@jskit-ai/crud-core"], crudCorePackage.version);
+  assert.equal(
+    descriptor.mutations.dependencies.runtime["@jskit-ai/resource-crud-core"],
+    resourceCrudCorePackage.version
+  );
 
   const expectedFileIds = [
     "users-core-users-package-json",
@@ -22,10 +28,8 @@ test("users-core installs the app-local users package scaffold", () => {
     "users-core-users-package-descriptor-workspace",
     "users-core-users-provider-base",
     "users-core-users-provider-workspace",
-    "users-core-users-action-ids",
     "users-core-users-actions-base",
     "users-core-users-actions-workspace",
-    "users-core-users-list-config",
     "users-core-users-routes-base",
     "users-core-users-routes-workspace",
     "users-core-users-repository",
@@ -58,17 +62,55 @@ test("users-core base users package templates stay aligned with non-workspace ap
     path.join(PACKAGE_ROOT, "templates/packages/users/src/server/actions.js"),
     "utf8"
   );
+  const repositorySource = await readFile(
+    path.join(PACKAGE_ROOT, "templates/packages/users/src/server/repository.js"),
+    "utf8"
+  );
+  const serviceSource = await readFile(
+    path.join(PACKAGE_ROOT, "templates/packages/users/src/server/service.js"),
+    "utf8"
+  );
   const routesSource = await readFile(
     path.join(PACKAGE_ROOT, "templates/packages/users/src/server/registerRoutes.js"),
     "utf8"
   );
 
   assert.doesNotMatch(packageDescriptorSource, /@jskit-ai\/workspaces-core/);
+  assert.match(packageDescriptorSource, /@jskit-ai\/json-rest-api-core/);
+  assert.match(packageDescriptorSource, /json-rest-api\.core/);
+  assert.doesNotMatch(packageDescriptorSource, /server\/actionIds/);
   assert.match(providerSource, /surface: "home"/);
   assert.doesNotMatch(providerSource, /routeSurfaceRequiresWorkspace/);
+  assert.doesNotMatch(providerSource, /createCrudLookup/);
+  assert.doesNotMatch(providerSource, /lookup\.users/);
+  assert.doesNotMatch(providerSource, /normalizeRecordId/);
+  assert.doesNotMatch(providerSource, /requires application singleton\(\)\/service\(\)\/actions\(\)\./);
+  assert.match(providerSource, /createJsonRestResourceScopeOptions/);
+  assert.match(providerSource, /addResourceIfMissing\(\s*api,\s*"users",\s*createJsonRestResourceScopeOptions\(resource,/s);
+  assert.match(repositorySource, /api\.resources\.users\.query\(/);
+  assert.match(repositorySource, /api\.resources\.users\.get\(/);
+  assert.match(repositorySource, /async function queryDocuments\(query = \{\}, options = \{\}\)/);
+  assert.match(repositorySource, /async function getDocumentById\(recordId, options = \{\}\)/);
+  assert.match(repositorySource, /returnNullWhenJsonRestResourceMissing/);
   assert.doesNotMatch(actionsSource, /workspaceSlugParamsValidator/);
+  assert.doesNotMatch(actionsSource, /requireActionSurface/);
+  assert.match(actionsSource, /orderBy: resource\.defaultSort/);
+  assert.match(actionsSource, /output: null/);
+  assert.match(actionsSource, /usersService\.queryDocuments/);
+  assert.match(actionsSource, /usersService\.getDocumentById/);
+  assert.doesNotMatch(actionsSource, /from "\.\/actionIds\.js"/);
+  assert.match(actionsSource, /id: "crud\.users\.list"/);
+  assert.match(actionsSource, /id: "crud\.users\.view"/);
+  assert.doesNotMatch(serviceSource, /serviceEvents/);
+  assert.match(serviceSource, /throw new TypeError\("createService requires usersRepository\."\);/);
+  assert.match(serviceSource, /return404IfNotFound/);
+  assert.match(serviceSource, /throw new AppError\(404, "Document not found\."\);/);
+  assert.match(serviceSource, /returnJsonApiDocument/);
   assert.doesNotMatch(routesSource, /workspaceRouteInput/);
+  assert.match(routesSource, /createJsonApiResourceRouteContract/);
+  assert.doesNotMatch(routesSource, /wrapResponse/);
   assert.match(routesSource, /routeBase: "\/"/);
+  assert.match(routesSource, /orderBy: resource\.defaultSort/);
 });
 
 test("users-core workspace users package templates stay aligned with workspace apps", async () => {
@@ -88,11 +130,36 @@ test("users-core workspace users package templates stay aligned with workspace a
     path.join(PACKAGE_ROOT, "templates/packages/users-workspace/src/server/registerRoutes.js"),
     "utf8"
   );
+  const serviceSource = await readFile(
+    path.join(PACKAGE_ROOT, "templates/packages/users/src/server/service.js"),
+    "utf8"
+  );
 
   assert.match(packageDescriptorSource, /@jskit-ai\/workspaces-core/);
+  assert.match(packageDescriptorSource, /@jskit-ai\/json-rest-api-core/);
+  assert.match(packageDescriptorSource, /json-rest-api\.core/);
+  assert.doesNotMatch(packageDescriptorSource, /server\/actionIds/);
   assert.match(providerSource, /surface: "admin"/);
   assert.match(providerSource, /routeSurfaceRequiresWorkspace/);
+  assert.doesNotMatch(providerSource, /createCrudLookup/);
+  assert.doesNotMatch(providerSource, /lookup\.users/);
+  assert.doesNotMatch(providerSource, /normalizeRecordId/);
+  assert.doesNotMatch(providerSource, /requires application singleton\(\)\/service\(\)\/actions\(\)\./);
+  assert.match(providerSource, /createJsonRestResourceScopeOptions/);
+  assert.match(providerSource, /addResourceIfMissing\(\s*api,\s*"users",\s*createJsonRestResourceScopeOptions\(resource,/s);
   assert.match(actionsSource, /workspaceSlugParamsValidator/);
+  assert.doesNotMatch(actionsSource, /requireActionSurface/);
+  assert.match(actionsSource, /orderBy: resource\.defaultSort/);
+  assert.match(actionsSource, /usersService\.queryDocuments/);
+  assert.match(actionsSource, /usersService\.getDocumentById/);
+  assert.doesNotMatch(actionsSource, /from "\.\/actionIds\.js"/);
+  assert.match(actionsSource, /id: "crud\.users\.list"/);
+  assert.match(actionsSource, /id: "crud\.users\.view"/);
   assert.match(routesSource, /buildWorkspaceInputFromRouteParams/);
+  assert.match(routesSource, /createJsonApiResourceRouteContract/);
+  assert.doesNotMatch(routesSource, /wrapResponse/);
   assert.match(routesSource, /routeBase: routeSurfaceRequiresWorkspace === true \? "\/w\/:workspaceSlug" : "\/"/);
+  assert.doesNotMatch(serviceSource, /serviceEvents/);
+  assert.match(serviceSource, /throw new TypeError\("createService requires usersRepository\."\);/);
+  assert.match(serviceSource, /returnJsonApiDocument/);
 });

package/test/usersRouteRequestInputValidator.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { UsersCoreServiceProvider } from "../src/server/UsersCoreServiceProvider.js";
+import { INTERNAL_JSON_REST_API } from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
+import { createRouter } from "../../kernel/server/http/lib/router.js";
 
 function createReplyDouble() {
   return {
@@ -29,21 +31,18 @@ function findRoute(routes, { method, path }) {
 async function registerRoutes({
   authService = {}
 } = {}) {
-  const registeredRoutes = [];
-  const router = {
-    register(method, path, route, handler) {
-      registeredRoutes.push({
-        ...route,
-        method,
-        path,
-        handler
-      });
+  const router = createRouter();
+  const internalApi = {
+    resources: {},
+    async addResource(scopeName) {
+      this.resources[scopeName] = {};
     }
   };
 
   const bindings = new Map([
     ["jskit.http.router", router],
     ["authService", authService],
+    [INTERNAL_JSON_REST_API, internalApi],
     [
       "users.accountProfile.service",
       {
@@ -62,6 +61,10 @@ async function registerRoutes({
     has(token) {
       return bindings.has(token);
     },
+    instance(token, value) {
+      bindings.set(token, value);
+      return this;
+    },
     make(token) {
       if (!bindings.has(token)) {
         throw new Error(`Missing test binding for token: ${String(token)}`);
@@ -73,7 +76,7 @@ async function registerRoutes({
   const provider = new UsersCoreServiceProvider();
   await provider.boot(app);
 
-  return registeredRoutes;
+  return router.list();
 }
 
 function createActionRequest({ input = {}, executeAction, file = null }) {
@@ -89,9 +92,34 @@ function createActionRequest({ input = {}, executeAction, file = null }) {
 
 test("users-core boot mounts account routes without workspace routes", async () => {
   const routes = await registerRoutes();
+  const settingsRoute = findRoute(routes, { method: "GET", path: "/api/settings" });
+  const profileRoute = findRoute(routes, { method: "PATCH", path: "/api/settings/profile" });
+  const preferencesRoute = findRoute(routes, { method: "PATCH", path: "/api/settings/preferences" });
+  const notificationsRoute = findRoute(routes, { method: "PATCH", path: "/api/settings/notifications" });
 
-  assert.equal(findRoute(routes, { method: "GET", path: "/api/settings" })?.path, "/api/settings");
-  assert.equal(findRoute(routes, { method: "PATCH", path: "/api/settings/profile" })?.path, "/api/settings/profile");
+  assert.equal(settingsRoute?.path, "/api/settings");
+  assert.equal(profileRoute?.path, "/api/settings/profile");
+  assert.equal(preferencesRoute?.path, "/api/settings/preferences");
+  assert.equal(notificationsRoute?.path, "/api/settings/notifications");
+  assert.equal(settingsRoute?.transport?.kind, "jsonapi-resource");
+  assert.equal(profileRoute?.transport?.kind, "jsonapi-resource");
+  assert.equal(preferencesRoute?.transport?.kind, "jsonapi-resource");
+  assert.equal(notificationsRoute?.transport?.kind, "jsonapi-resource");
+  assert.equal(settingsRoute?.schema?.response?.[200]?.required?.[0], "data");
+  assert.equal(profileRoute?.schema?.body?.required?.[0], "data");
+  assert.equal(profileRoute?.schema?.response?.[200]?.required?.[0], "data");
+  assert.equal(
+    profileRoute?.schema?.body?.definitions?.["user-profilesRequestResource"]?.properties?.type?.const,
+    "user-profiles"
+  );
+  assert.equal(
+    settingsRoute?.schema?.response?.[200]?.definitions?.["user-settingsSuccessResource"]?.properties?.type?.const,
+    "user-settings"
+  );
+  assert.equal(
+    typeof findRoute(routes, { method: "GET", path: "/api/settings/security/oauth/:provider/start" })?.schema?.response?.[302],
+    "object"
+  );
   assert.equal(findRoute(routes, { method: "GET", path: "/api/workspaces" }), null);
   assert.equal(findRoute(routes, { method: "GET", path: "/api/w/:workspaceSlug/settings" }), null);
 });
@@ -109,10 +137,10 @@ test("account route handlers build action input from request.input", async () =>
       return { url: "/oauth/link" };
     }
     if (payload.actionId === "settings.profile.update") {
-      return { settings: {}, session: null };
+      return { response: { __jskitJsonApiResult: true, kind: "data", value: {} }, session: null };
     }
     if (payload.actionId === "settings.security.password.change") {
-      return { message: "ok", session: null };
+      return { response: { __jskitJsonApiResult: true, kind: "meta", value: { message: "ok" } }, session: null };
     }
     return {};
   };
@@ -183,19 +211,60 @@ test("account route handlers build action input from request.input", async () =>
     createReplyDouble()
   );
 
-  assert.deepEqual(calls[0].input, { payload: { displayName: "Merc" } });
-  assert.deepEqual(calls[1].input, { payload: { locale: "en-US" } });
-  assert.deepEqual(calls[2].input, { payload: { email: true } });
+  assert.deepEqual(calls[0].input, { displayName: "Merc" });
+  assert.deepEqual(calls[1].input, { locale: "en-US" });
+  assert.deepEqual(calls[2].input, { email: true });
   assert.deepEqual(calls[3].input, {
-    payload: {
-      currentPassword: "old-password",
-      newPassword: "new-password-123",
-      confirmPassword: "new-password-123"
-    }
+    currentPassword: "old-password",
+    newPassword: "new-password-123",
+    confirmPassword: "new-password-123"
   });
-  assert.deepEqual(calls[4].input, { payload: { enabled: true } });
+  assert.deepEqual(calls[4].input, { enabled: true });
   assert.deepEqual(calls[5].input, { provider: "github", returnTo: "/app/settings" });
   assert.equal(oauthReply.redirectedTo, "/oauth/link");
   assert.deepEqual(calls[6].input, { provider: "github" });
   assert.equal(calls[7].actionId, "settings.security.sessions.logout_others");
 });
+
+test("account settings jsonapi transport resolves response resource id from request user", async () => {
+  const routes = await registerRoutes();
+  const settingsRoute = findRoute(routes, { method: "GET", path: "/api/settings" });
+
+  const document = settingsRoute.transport.response(
+    {
+      __jskitJsonApiResult: true,
+      kind: "data",
+      value: {
+        profile: {
+          displayName: "Merc"
+        },
+        security: {},
+        preferences: {},
+        notifications: {}
+      }
+    },
+    {
+      request: {
+        user: {
+          id: 42
+        }
+      },
+      statusCode: 200
+    }
+  );
+
+  assert.deepEqual(document, {
+    data: {
+      type: "user-settings",
+      id: "42",
+      attributes: {
+        profile: {
+          displayName: "Merc"
+        },
+        security: {},
+        preferences: {},
+        notifications: {}
+      }
+    }
+  });
+});

package/test/usersRouteResources.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
-import "../test-support/registerDefaultSettingsFields.js";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { userProfileResource } from "../src/shared/resources/userProfileResource.js";
 import { userSettingsResource } from "../src/shared/resources/userSettingsResource.js";
 
@@ -27,15 +27,18 @@ function assertResourceShape(resource, label) {
       `${label}.operations.${operationName} must resolve messages from operation.messages or resource.messages.`
     );
     assert.equal(
-      typeof operation.outputValidator?.schema,
+      typeof resolveStructuredSchemaTransportSchema(operation.output, {
+        context: `${label}.operations.${operationName}.output`,
+        defaultMode: "replace"
+      }),
       "object",
       `${label}.operations.${operationName} payload schema is required.`
     );
   }
 
-  assert.equal(typeof resource.operations.create.bodyValidator?.schema, "object", `${label}.operations.create.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.replace.bodyValidator?.schema, "object", `${label}.operations.replace.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.patch.bodyValidator?.schema, "object", `${label}.operations.patch.bodyValidator.schema is required.`);
+  assert.equal(typeof resource.operations.create.body?.schema, "object", `${label}.operations.create.body.schema is required.`);
+  assert.equal(typeof resource.operations.replace.body?.schema, "object", `${label}.operations.replace.body.schema is required.`);
+  assert.equal(typeof resource.operations.patch.body?.schema, "object", `${label}.operations.patch.body.schema is required.`);
 
   const requiredMetadata = deriveResourceRequiredMetadata(resource);
   assert.ok(Array.isArray(requiredMetadata.create), `${label}.derivedRequired.create must be an array.`);
@@ -67,29 +70,36 @@ test("specialized settings and invite operations expose canonical validators", (
 
   for (const { label, operation } of operationSpecs) {
     assert.equal(typeof operation?.method, "string", `${label}.method must exist.`);
-    assert.equal(typeof operation?.outputValidator?.schema, "object", `${label}.outputValidator.schema must exist.`);
-    if (operation?.bodyValidator) {
-      assert.equal(typeof operation.bodyValidator.schema, "object", `${label}.bodyValidator.schema must exist.`);
+    assert.equal(
+      typeof resolveStructuredSchemaTransportSchema(operation?.output, {
+        context: `${label}.output`,
+        defaultMode: "replace"
+      }),
+      "object",
+      `${label}.output transport schema must exist.`
+    );
+    if (operation?.body) {
+      assert.equal(typeof operation.body.schema, "object", `${label}.body.schema must exist.`);
     }
-    if (operation?.paramsValidator) {
-      assert.equal(typeof operation.paramsValidator.schema, "object", `${label}.paramsValidator.schema must exist.`);
+    if (operation?.params) {
+      assert.equal(typeof operation.params.schema, "object", `${label}.params.schema must exist.`);
     }
-    if (operation?.queryValidator) {
-      assert.equal(typeof operation.queryValidator.schema, "object", `${label}.queryValidator.schema must exist.`);
+    if (operation?.query) {
+      assert.equal(typeof operation.query.schema, "object", `${label}.query.schema must exist.`);
     }
   }
 });
 
-test("users-core no longer uses a workspace schema helper that exposes raw schema leaves", () => {
+test("users-core does not use workspaceRoutes.js helper that exposes raw schema leaves", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacyWorkspaceRoutesFile = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
-  assert.equal(existsSync(legacyWorkspaceRoutesFile), false, "workspaceRoutes.js must not exist.");
+  const workspaceRoutesFilePath = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
+  assert.equal(existsSync(workspaceRoutesFilePath), false, "workspaceRoutes.js must not exist.");
 });
 
-test("users-core route validators no longer live under a legacy shared/schema directory", () => {
+test("users-core route validators do not live under src/shared/schema", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
-  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+  const sharedSchemaDirPath = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(sharedSchemaDirPath), false, "src/shared/schema must not exist.");
 });

package/src/server/common/resources/userProfilesResource.js

@@ -1,203 +0,0 @@
-import { Type } from "typebox";
-import { normalizeDbRecordId, toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
-import {
-  createCursorListValidator,
-  normalizeObjectInput,
-  recordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import {
-  normalizeIfPresent,
-  normalizeLowerText,
-  normalizeText,
-  normalizeOrNull
-} from "@jskit-ai/kernel/shared/support/normalize";
-
-const USERNAME_MAX_LENGTH = 120;
-
-function normalizeUsername(value) {
-  const normalized = normalizeLowerText(value)
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, USERNAME_MAX_LENGTH);
-
-  return normalized || "";
-}
-
-function normalizeNullableString(value) {
-  if (value === null || value === undefined) {
-    return null;
-  }
-
-  return normalizeText(value);
-}
-
-function normalizeNullableVersion(value) {
-  if (value === null || value === undefined || value === "") {
-    return null;
-  }
-
-  return String(value);
-}
-
-function normalizeProfileRecord(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const id = normalizeIfPresent(source.id, (value) => normalizeDbRecordId(value, { fallback: null }));
-  const displayName = normalizeText(source.displayName ?? source.display_name);
-  const email = normalizeLowerText(source.email);
-  const username = normalizeUsername(source.username);
-
-  return {
-    id,
-    authProvider: normalizeLowerText(source.authProvider ?? source.auth_provider),
-    authProviderUserSid: normalizeText(source.authProviderUserSid ?? source.auth_provider_user_sid),
-    email,
-    username,
-    displayName,
-    avatarStorageKey: normalizeOrNull(source.avatarStorageKey ?? source.avatar_storage_key, normalizeNullableString),
-    avatarVersion: normalizeNullableVersion(source.avatarVersion ?? source.avatar_version),
-    avatarUpdatedAt: normalizeOrNull(source.avatarUpdatedAt ?? source.avatar_updated_at, toIsoString),
-    createdAt: normalizeIfPresent(source.createdAt ?? source.created_at, toIsoString)
-  };
-}
-
-function normalizeCreatePayload(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
-
-  if (Object.hasOwn(source, "authProvider") || Object.hasOwn(source, "provider")) {
-    normalized.authProvider = normalizeLowerText(source.authProvider ?? source.provider);
-  }
-  if (Object.hasOwn(source, "authProviderUserSid") || Object.hasOwn(source, "providerUserId")) {
-    normalized.authProviderUserSid = normalizeText(source.authProviderUserSid ?? source.providerUserId);
-  }
-  if (Object.hasOwn(source, "email")) {
-    normalized.email = normalizeLowerText(source.email);
-  }
-  if (Object.hasOwn(source, "username")) {
-    normalized.username = normalizeUsername(source.username);
-  }
-  if (Object.hasOwn(source, "displayName")) {
-    normalized.displayName = normalizeText(source.displayName);
-  }
-  if (Object.hasOwn(source, "avatarStorageKey")) {
-    normalized.avatarStorageKey = normalizeNullableString(source.avatarStorageKey);
-  }
-  if (Object.hasOwn(source, "avatarVersion")) {
-    normalized.avatarVersion = normalizeNullableVersion(source.avatarVersion);
-  }
-  if (Object.hasOwn(source, "avatarUpdatedAt")) {
-    normalized.avatarUpdatedAt = toNullableDateTime(source.avatarUpdatedAt);
-  }
-
-  return normalized;
-}
-
-const recordOutputSchema = Type.Object(
-  {
-    id: recordIdSchema,
-    authProvider: Type.String({ minLength: 1 }),
-    authProviderUserSid: Type.String({ minLength: 1 }),
-    email: Type.String({ minLength: 1 }),
-    username: Type.String({ minLength: 1 }),
-    displayName: Type.String({ minLength: 1 }),
-    avatarStorageKey: Type.Union([Type.String(), Type.Null()]),
-    avatarVersion: Type.Union([Type.String(), Type.Null()]),
-    avatarUpdatedAt: Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]),
-    createdAt: Type.String({ format: "date-time", minLength: 1 })
-  },
-  { additionalProperties: false }
-);
-
-const createBodySchema = Type.Object(
-  {
-    authProvider: Type.String({ minLength: 1, maxLength: 64 }),
-    authProviderUserSid: Type.String({ minLength: 1, maxLength: 191 }),
-    email: Type.String({ minLength: 1, maxLength: 255 }),
-    username: Type.Optional(Type.String({ minLength: 1, maxLength: USERNAME_MAX_LENGTH })),
-    displayName: Type.String({ minLength: 1, maxLength: 160 }),
-    avatarStorageKey: Type.Optional(Type.Union([Type.String({ maxLength: 512 }), Type.Null()])),
-    avatarVersion: Type.Optional(Type.Union([Type.String({ maxLength: 64 }), Type.Null()])),
-    avatarUpdatedAt: Type.Optional(Type.Union([Type.String({ format: "date-time", minLength: 1 }), Type.Null()]))
-  },
-  {
-    additionalProperties: false,
-    required: []
-  }
-);
-
-const patchBodySchema = Type.Partial(createBodySchema, {
-  additionalProperties: false
-});
-
-const recordOutputValidator = Object.freeze({
-  schema: recordOutputSchema,
-  normalize: normalizeProfileRecord
-});
-
-const createBodyValidator = Object.freeze({
-  schema: createBodySchema,
-  normalize: normalizeCreatePayload
-});
-
-const patchBodyValidator = Object.freeze({
-  schema: patchBodySchema,
-  normalize: normalizeCreatePayload
-});
-
-const resource = Object.freeze({
-  namespace: "userProfiles",
-  tableName: "users",
-  idColumn: "id",
-  operations: Object.freeze({
-    list: Object.freeze({
-      method: "GET",
-      outputValidator: createCursorListValidator(recordOutputValidator)
-    }),
-    view: Object.freeze({
-      method: "GET",
-      outputValidator: recordOutputValidator
-    }),
-    create: Object.freeze({
-      method: "POST",
-      bodyValidator: createBodyValidator,
-      outputValidator: recordOutputValidator
-    }),
-    patch: Object.freeze({
-      method: "PATCH",
-      bodyValidator: patchBodyValidator,
-      outputValidator: recordOutputValidator
-    })
-  }),
-  fieldMeta: Object.freeze([
-    Object.freeze({
-      key: "authProvider",
-      repository: { column: "auth_provider" }
-    }),
-    Object.freeze({
-      key: "authProviderUserSid",
-      repository: { column: "auth_provider_user_sid" }
-    }),
-    Object.freeze({
-      key: "displayName",
-      repository: { column: "display_name" }
-    }),
-    Object.freeze({
-      key: "avatarStorageKey",
-      repository: { column: "avatar_storage_key" }
-    }),
-    Object.freeze({
-      key: "avatarVersion",
-      repository: { column: "avatar_version" }
-    }),
-    Object.freeze({
-      key: "avatarUpdatedAt",
-      repository: { column: "avatar_updated_at" }
-    }),
-    Object.freeze({
-      key: "createdAt",
-      repository: { column: "created_at" }
-    })
-  ])
-});
-
-export { resource };