@jskit-ai/users-core 0.1.105 → 0.1.107

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-core",
-  version: "0.1.105",
+  version: "0.1.107",
   kind: "runtime",
   description: "Users/account runtime plus HTTP routes for account features.",
   dependsOn: [
@@ -143,16 +143,16 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.94",
-        "@jskit-ai/crud-core": "0.1.103",
-        "@jskit-ai/database-runtime": "0.1.95",
-        "@jskit-ai/http-runtime": "0.1.94",
-        "@jskit-ai/json-rest-api-core": "0.1.40",
-        "@jskit-ai/kernel": "0.1.95",
-        "@jskit-ai/resource-core": "0.1.40",
-        "@jskit-ai/resource-crud-core": "0.1.40",
+        "@jskit-ai/auth-core": "0.1.96",
+        "@jskit-ai/crud-core": "0.1.105",
+        "@jskit-ai/database-runtime": "0.1.97",
+        "@jskit-ai/http-runtime": "0.1.96",
+        "@jskit-ai/json-rest-api-core": "0.1.42",
+        "@jskit-ai/kernel": "0.1.98",
+        "@jskit-ai/resource-core": "0.1.42",
+        "@jskit-ai/resource-crud-core": "0.1.42",
         "@local/users": "file:packages/users",
-        "@jskit-ai/uploads-runtime": "0.1.73"
+        "@jskit-ai/uploads-runtime": "0.1.75"
       },
       dev: {}
     },

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "@jskit-ai/users-core",
-  "version": "0.1.105",
+  "version": "0.1.107",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
+    "./server/previewUserProvisioning": "./src/server/previewUserProvisioning.js",
     "./server/profileSyncLifecycleContributorRegistry": "./src/server/profileSyncLifecycleContributorRegistry.js",
     "./shared/resources/userProfileResource": "./src/shared/resources/userProfileResource.js",
     "./shared/resources/userSettingsResource": "./src/shared/resources/userSettingsResource.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.94",
-    "@jskit-ai/database-runtime": "0.1.95",
-    "@jskit-ai/http-runtime": "0.1.94",
-    "@jskit-ai/json-rest-api-core": "0.1.40",
-    "@jskit-ai/kernel": "0.1.95",
-    "@jskit-ai/resource-crud-core": "0.1.40",
-    "@jskit-ai/resource-core": "0.1.40",
-    "@jskit-ai/uploads-runtime": "0.1.73",
+    "@jskit-ai/auth-core": "0.1.96",
+    "@jskit-ai/database-runtime": "0.1.97",
+    "@jskit-ai/http-runtime": "0.1.96",
+    "@jskit-ai/json-rest-api-core": "0.1.42",
+    "@jskit-ai/kernel": "0.1.98",
+    "@jskit-ai/resource-crud-core": "0.1.42",
+    "@jskit-ai/resource-core": "0.1.42",
+    "@jskit-ai/uploads-runtime": "0.1.75",
     "json-rest-schema": "1.x.x"
   }
 }

package/src/server/previewUserProvisioning.js

@@ -0,0 +1,207 @@
+import { DEFAULT_USER_SETTINGS } from "../shared/settings.js";
+
+const DEFAULT_AUTH_PROVIDER = "jskit-preview";
+const DEFAULT_EMAIL = "preview@jskit.local";
+const DEFAULT_DISPLAY_NAME = "JSKIT Preview";
+const USERNAME_MAX_LENGTH = 120;
+
+function normalizeText(value = "") {
+  return String(value || "").trim();
+}
+
+function normalizeLowerText(value = "") {
+  return normalizeText(value).toLowerCase();
+}
+
+function normalizeUsername(value = "") {
+  const normalized = normalizeLowerText(value)
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, USERNAME_MAX_LENGTH);
+  return normalized || "";
+}
+
+function usernameBaseFromEmail(email = "") {
+  const normalizedEmail = normalizeLowerText(email);
+  const localPart = normalizedEmail.includes("@") ? normalizedEmail.split("@")[0] : normalizedEmail;
+  return normalizeUsername(localPart) || "user";
+}
+
+function buildUsernameCandidate(baseUsername = "", suffix = 0) {
+  const base = normalizeUsername(baseUsername) || "user";
+  if (suffix < 1) {
+    return base;
+  }
+  const suffixText = `-${suffix + 1}`;
+  return `${base.slice(0, USERNAME_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 normalizePreviewUserProfile(profile = {}) {
+  const email = normalizeLowerText(profile.email || DEFAULT_EMAIL);
+  const authProvider = normalizeLowerText(profile.authProvider || DEFAULT_AUTH_PROVIDER);
+  const username = normalizeUsername(profile.username || usernameBaseFromEmail(email));
+
+  return {
+    authProvider,
+    authProviderUserSid: normalizeText(profile.authProviderUserSid || `${authProvider}:${email}`),
+    displayName: normalizeText(profile.displayName || username || email || DEFAULT_DISPLAY_NAME),
+    email,
+    username: username || usernameBaseFromEmail(email)
+  };
+}
+
+function profileFromUserRow(user = {}, fallback = {}) {
+  return {
+    id: normalizeText(user.id),
+    authProvider: normalizeLowerText(user.auth_provider || fallback.authProvider || DEFAULT_AUTH_PROVIDER),
+    authProviderUserSid: normalizeText(user.auth_provider_user_sid || fallback.authProviderUserSid || user.id || ""),
+    displayName: normalizeText(user.display_name || fallback.displayName || fallback.email || DEFAULT_DISPLAY_NAME),
+    email: normalizeLowerText(user.email || fallback.email || DEFAULT_EMAIL),
+    username: normalizeUsername(user.username || fallback.username || usernameBaseFromEmail(fallback.email))
+  };
+}
+
+async function resolveUniqueUsername(db, baseUsername = "", { excludeUserId = "" } = {}) {
+  const normalizedExcludeUserId = normalizeText(excludeUserId);
+  for (let suffix = 0; suffix < 1000; suffix += 1) {
+    const candidate = buildUsernameCandidate(baseUsername, suffix);
+    const existing = await db("users")
+      .where({ username: candidate })
+      .first();
+    if (!existing || normalizeText(existing.id) === normalizedExcludeUserId) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to generate unique preview username.");
+}
+
+async function findPreviewUser(db, profile = {}) {
+  if (profile.email) {
+    const byEmail = await db("users")
+      .where({ email: profile.email })
+      .first();
+    if (byEmail) {
+      return byEmail;
+    }
+  }
+  return db("users")
+    .where({
+      auth_provider: profile.authProvider,
+      auth_provider_user_sid: profile.authProviderUserSid
+    })
+    .first();
+}
+
+async function ensurePreviewUserRow(db, profile = {}) {
+  const existing = await findPreviewUser(db, profile);
+  const username = await resolveUniqueUsername(db, profile.username, {
+    excludeUserId: existing?.id
+  });
+  const record = {
+    auth_provider: profile.authProvider,
+    auth_provider_user_sid: profile.authProviderUserSid,
+    display_name: profile.displayName,
+    email: profile.email,
+    username
+  };
+
+  if (existing) {
+    await db("users")
+      .where({ id: existing.id })
+      .update(record);
+    return db("users")
+      .where({ id: existing.id })
+      .first();
+  }
+
+  try {
+    await db("users").insert(record);
+  } catch (error) {
+    if (!isDuplicateError(error)) {
+      throw error;
+    }
+  }
+
+  const inserted = await findPreviewUser(db, {
+    ...profile,
+    username
+  });
+  if (!inserted) {
+    throw new Error("Preview auth profile could not be inserted or found.");
+  }
+  return inserted;
+}
+
+async function ensureUserSettings(db, user = {}) {
+  if (!(await db.schema.hasTable("user_settings"))) {
+    return false;
+  }
+  const userId = user?.id;
+  const existing = await db("user_settings")
+    .where({ user_id: userId })
+    .first();
+  if (existing) {
+    return false;
+  }
+  try {
+    await db("user_settings").insert({
+      user_id: userId,
+      theme: DEFAULT_USER_SETTINGS.theme,
+      locale: DEFAULT_USER_SETTINGS.locale,
+      time_zone: DEFAULT_USER_SETTINGS.timeZone,
+      date_format: DEFAULT_USER_SETTINGS.dateFormat,
+      number_format: DEFAULT_USER_SETTINGS.numberFormat,
+      currency_code: DEFAULT_USER_SETTINGS.currencyCode,
+      avatar_size: DEFAULT_USER_SETTINGS.avatarSize,
+      password_sign_in_enabled: DEFAULT_USER_SETTINGS.passwordSignInEnabled,
+      password_setup_required: DEFAULT_USER_SETTINGS.passwordSetupRequired,
+      notify_product_updates: DEFAULT_USER_SETTINGS.productUpdates,
+      notify_account_activity: DEFAULT_USER_SETTINGS.accountActivity,
+      notify_security_alerts: DEFAULT_USER_SETTINGS.securityAlerts
+    });
+  } catch (error) {
+    if (!isDuplicateError(error)) {
+      throw error;
+    }
+  }
+  return true;
+}
+
+async function ensurePreviewUser(db, profileInput = {}) {
+  if (!db || typeof db !== "function" || !db.schema || typeof db.schema.hasTable !== "function") {
+    throw new TypeError("ensurePreviewUser requires a Knex database instance.");
+  }
+  if (!(await db.schema.hasTable("users"))) {
+    return {
+      user: null,
+      profile: null,
+      skipped: "users table was not found"
+    };
+  }
+
+  const profile = normalizePreviewUserProfile(profileInput);
+  const user = await ensurePreviewUserRow(db, profile);
+  await ensureUserSettings(db, user);
+
+  return {
+    user,
+    profile: profileFromUserRow(user, profile),
+    skipped: ""
+  };
+}
+
+export {
+  DEFAULT_AUTH_PROVIDER,
+  DEFAULT_DISPLAY_NAME,
+  DEFAULT_EMAIL,
+  ensurePreviewUser,
+  normalizePreviewUserProfile,
+  profileFromUserRow
+};

package/test/exportsContract.test.js

@@ -12,7 +12,10 @@ test("users-core exports are explicit and aligned with production/template usage
   const result = evaluatePackageExportsContract({
     repoRoot: REPO_ROOT,
     packageDir: PACKAGE_DIR,
-    packageId: "@jskit-ai/users-core"
+    packageId: "@jskit-ai/users-core",
+    requiredExports: [
+      "./server/previewUserProvisioning"
+    ]
   });
 
   assert.deepEqual(

package/test/previewUserProvisioning.test.js

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ensurePreviewUser } from "../src/server/previewUserProvisioning.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 = {};
+
+    return {
+      where(nextCriteria = {}) {
+        criteria = { ...criteria, ...nextCriteria };
+        return this;
+      },
+      async first() {
+        return rows.find((row) => matches(row, criteria)) || 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("ensurePreviewUser creates preview user and settings with package defaults", async () => {
+  const db = createMemoryDb({
+    users: [],
+    user_settings: []
+  });
+
+  const result = await ensurePreviewUser(db, {
+    email: " Preview@Example.TEST ",
+    displayName: "Preview User"
+  });
+
+  assert.equal(result.skipped, "");
+  assert.equal(result.profile.email, "preview@example.test");
+  assert.equal(result.profile.username, "preview");
+  assert.equal(result.profile.authProvider, "jskit-preview");
+  assert.equal(db.tables.users.length, 1);
+  assert.equal(db.tables.user_settings.length, 1);
+  assert.equal(db.tables.user_settings[0].theme, "system");
+  assert.equal(db.tables.user_settings[0].password_sign_in_enabled, true);
+});
+
+test("ensurePreviewUser updates the existing preview row without stealing another username", async () => {
+  const db = createMemoryDb({
+    users: [
+      {
+        id: "1",
+        auth_provider: "supabase",
+        auth_provider_user_sid: "other",
+        email: "taken@example.test",
+        username: "preview",
+        display_name: "Other"
+      },
+      {
+        id: "2",
+        auth_provider: "jskit-preview",
+        auth_provider_user_sid: "jskit-preview:preview@example.test",
+        email: "preview@example.test",
+        username: "old-preview",
+        display_name: "Old"
+      }
+    ],
+    user_settings: [
+      {
+        user_id: "2"
+      }
+    ]
+  });
+
+  const result = await ensurePreviewUser(db, {
+    email: "preview@example.test",
+    username: "preview",
+    displayName: "New Preview"
+  });
+
+  assert.equal(result.profile.id, "2");
+  assert.equal(result.profile.username, "preview-2");
+  assert.equal(db.tables.users.find((row) => row.id === "2").display_name, "New Preview");
+  assert.equal(db.tables.user_settings.length, 1);
+});
+
+test("ensurePreviewUser skips when the users table is absent", async () => {
+  const db = createMemoryDb({});
+
+  const result = await ensurePreviewUser(db, {
+    email: "preview@example.test"
+  });
+
+  assert.deepEqual(result, {
+    user: null,
+    profile: null,
+    skipped: "users table was not found"
+  });
+});