serene-core-server 0.1.1

package/src/services/users/service.ts

@@ -0,0 +1,293 @@
+import { PrismaClient } from '@/prisma/client'
+import { CustomError } from '../../types/errors'
+import { UserProfileModel } from '../../models/users/user-profile-model'
+import { UserModel } from '../../models/users/user-model'
+import { UserPreferenceService } from '../user-preference/service'
+
+export class UsersService {
+
+  // Consts
+  clName = 'UsersService'
+
+  // Models
+  userModel = new UserModel()
+  userProfileModel = new UserProfileModel()
+
+  // Services
+  userPreferenceService = new UserPreferenceService()
+
+  // Code
+  async createBlankUser(prisma: PrismaClient) {
+
+    // console.log('UsersService.createBlankUser(): start')
+
+    return await this.userProfileModel.create(
+                   prisma,
+                   null,       // userId
+                   false,      // isAdmin
+                   null)       // deletePending
+  }
+
+  async createDefaultUserPreferences(
+          prisma: PrismaClient,
+          userProfileId: string,
+          defaultUserPreferences: string | undefined) {
+
+    // console.log('createDefaultUserPreferences()')
+
+    if (defaultUserPreferences == null ||
+        defaultUserPreferences === '') {
+      return
+    }
+
+    const jsonArray: any[] = JSON.parse(defaultUserPreferences)
+
+    for (const json of jsonArray) {
+      await this.userPreferenceService.createIfNotExists(
+              prisma,
+              userProfileId,
+              json.category,
+              json.key,
+              json.value,
+              null)
+    }
+  }
+
+  async createUserByEmail(
+          prisma: PrismaClient,
+          email: string) {
+
+    const user = await
+            this.userModel.create(
+              prisma,
+              email,
+              undefined)  // name
+
+    const userProfile = await
+            this.userProfileModel.create(
+              prisma,
+              user.id,
+              false,  // isAdmin
+              null)   // deletePending
+
+    return userProfile.id
+  }
+
+  async getById(prisma: PrismaClient,
+                userProfileId: string) {
+
+    return await this.userProfileModel.getById(
+             prisma,
+             userProfileId)
+  }
+
+  async getUserByUserProfileId(
+          prisma: PrismaClient,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getUserByUserProfileId()`
+
+    // Get userProfile
+    const userProfile = await
+            this.getById(
+              prisma,
+              userProfileId)
+
+    // Validate
+    if (userProfile == null) {
+      throw new CustomError(`${fnName}: userProfile == null`)
+    }
+
+    // Get user record
+    if (userProfile.userId == null) {
+      return null
+    } else {
+      return await this.userModel.getById(
+                     prisma,
+                     userProfile.userId)
+    }
+  }
+
+  async getOrCreateSignedOutUser(
+          prisma: PrismaClient,
+          signedOutId: string,
+          defaultUserPreferences: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getOrCreateSignedOutUser()`
+
+    // User id exists, use it
+    var userProfile: any = null
+
+    var signedOutUserProfile = {
+      id: signedOutId
+    }
+
+    if (signedOutId != null) {
+      // console.log(`${fnName}: getting user..`)
+
+      userProfile = await
+        this.getById(
+          prisma,
+          signedOutId)
+
+      if (userProfile) {
+        if (userProfile.id) {
+          signedOutUserProfile = userProfile
+        }
+      }
+    }
+
+    if (userProfile == null) {
+
+      // Create user record
+      // console.log(`${fnName}: creating user..`)
+
+      const userProfile = await this.createBlankUser(prisma)
+
+      // console.log(`${fnName}: userProfileId: ${userProfile.id}`)
+
+      signedOutUserProfile = userProfile
+      signedOutId = userProfile.id
+    }
+
+    // Create default user preferences
+    await this.createDefaultUserPreferences(
+            prisma,
+            signedOutId,
+            defaultUserPreferences)
+
+    // Return signedOutId
+    return signedOutUserProfile
+  }
+
+  async getOrCreateUserByEmail(
+          prisma: PrismaClient,
+          email: string,
+          defaultUserPreferences: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.getOrCreateUserByEmail()`
+
+    // console.log(`UsersService.getOrCreateUserByEmail(): email: ${email}`)
+
+    // Get/create user record
+    var signedInUser = await
+          this.userModel.getByEmail(
+            prisma,
+            email)
+
+    if (signedInUser == null) {
+
+      signedInUser = await
+        this.userModel.create(
+          prisma,
+          email,
+          undefined)  // name
+    }
+
+    // Get/create userProfile record
+    // console.log(`UsersService.getOrCreateUserByEmail(): get userProfile ` +
+    //             `records where signedInUser.id = ${signedInUser.id}`)
+
+    var signedInUserProfile = await
+          this.userProfileModel.getByUserId(
+            prisma,
+            signedInUser.id)
+
+    // console.log(`signedInUserProfile: ` + JSON.stringify(signedInUserProfile))
+
+    if (signedInUserProfile == null) {
+
+      // Create userProfile record
+      signedInUserProfile = await
+        this.userProfileModel.create(
+          prisma,
+          signedInUser.id,  // userId
+          false,            // isAdmin
+          null)             // deletePending
+    }
+
+    // Create default user preferences
+    await this.createDefaultUserPreferences(
+            prisma,
+            signedInUserProfile.id,
+            defaultUserPreferences)
+
+    return signedInUserProfile
+  }
+
+  async getUserProfileByEmail(
+          prisma: PrismaClient,
+          email: string) {
+
+    // console.log(`UsersService.getUserProfileByEmail(): emailLower: ${emailLower}`)
+
+    const user = await
+            this.userModel.getByEmail(
+              prisma,
+              email)
+
+    if (user == null) {
+      return null
+    } else {
+      return await this.userProfileModel.getByUserId(
+                     prisma,
+                     user.id)
+    }
+  }
+
+  async verifyHumanUserProfile(
+          prisma: PrismaClient,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.verifyHumanUserProfile()`
+
+    // Get UserProfile record
+    const userProfile = await
+            this.getById(
+              prisma,
+              userProfileId)
+
+    // Validate
+    if (userProfile == null) {
+      throw new CustomError(`${fnName}: userProfile == null`)
+    }
+
+    // Verify human roleOwnerType, or set if none
+    if (userProfile.ownerType == null) {
+
+      await this.userProfileModel.setOwnerType(
+              prisma,
+              userProfile)
+    }
+  }
+
+  async verifySignedInUserProfileId(
+          prisma: PrismaClient,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.verifySignedInUserProfileId()`
+
+    // Get UserProfile
+    const userProfile = await
+            this.userProfileModel.getById(
+              prisma,
+              userProfileId)
+
+    // Validate
+    if (userProfile == null) {
+      throw new CustomError(`${fnName}: userProfile == null`)
+    }
+
+    // Return
+    if (userProfile.userId == null) {
+      return false
+    } else {
+      return true
+    }
+  }
+}

package/src/services/users/user-error-service.ts

@@ -0,0 +1,74 @@
+import { PrismaClient } from '@/prisma/client'
+import { UserErrorModel } from '../../models/users/user-error-model'
+import { UserErrorSummaryModel } from '../../models/users/user-error-summary-model'
+
+// Models
+const userErrorModel = new UserErrorModel()
+const userErrorSummaryModel = new UserErrorSummaryModel()
+
+// Class
+export class UserErrorService {
+
+  async upsert(
+          prisma: PrismaClient,
+          userProfileId: string,
+          endUserProfileId: string | null,
+          instanceId: string | null,
+          summaryMessage: string | undefined,
+          origin: string,
+          message: string,
+          techMessage: string | null) {
+
+    // If the summaryMessage isn't specified, set it to the message
+    if (summaryMessage == null) {
+      summaryMessage = message
+    }
+
+    // Get the existing UserErrorSummary if it exists
+    var userErrorSummary = await
+          userErrorSummaryModel.getByUniqueKey(
+            prisma,
+            userProfileId,
+            instanceId,
+            origin,
+            summaryMessage)
+
+    // Create/update UserErrorSummary
+    if (userErrorSummary == null) {
+
+      // Create
+      userErrorSummary = await
+        userErrorSummaryModel.create(
+          prisma,
+          userProfileId,
+          instanceId,
+          origin,
+          summaryMessage,
+          1)  // count
+    } else {
+
+      // Inc count
+      userErrorSummary = await
+        userErrorSummaryModel.update(
+          prisma,
+          userErrorSummary.id,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          userErrorSummary.count + 1)
+    }
+
+    // Create UserError
+    const userError = await
+            userErrorModel.create(
+              prisma,
+              userErrorSummary.id,
+              userProfileId,
+              endUserProfileId,
+              instanceId,
+              origin,
+              message,
+              techMessage)
+  }
+}

package/src/services/users/users-group-service.ts

@@ -0,0 +1,85 @@
+import { PrismaClient } from '@/prisma/client'
+import { UserGroupMemberModel } from '../../models/users/user-group-member-model'
+import { UserGroupModel } from '../../models/users/user-group-model'
+
+export class UsersGroupService {
+
+  // Consts
+  clName = 'UsersGroupService'
+
+  // Common group names
+  externalUsersGroupName = 'External users group'
+
+  // Models
+  userGroupMemberModel = new UserGroupMemberModel()
+  userGroupModel = new UserGroupModel()
+
+  // Code
+  async verifyGroupMemberByOwner(
+          prisma: PrismaClient,
+          memberUserProfileId: string,
+          ownerUserProfileId: string,
+          groupName: string) {
+
+    // Get the UserGroup record
+    const userGroup = await
+            this.userGroupModel.getByUniqueKey(
+              prisma,
+              ownerUserProfileId,
+              groupName)
+
+    if (userGroup == null) {
+
+      return {
+        status: false,
+        message: `User group not found: ` + groupName
+      }
+    }
+
+    // Verify the member is present for the group
+    const memberUserGroupMember = await
+            this.userGroupMemberModel.getByUniqueKey(
+              prisma,
+              userGroup.id,
+              memberUserProfileId)
+
+    if (memberUserGroupMember == null) {
+
+      return {
+        status: false,
+        message: `Member: ${memberUserProfileId} not found for group: ` +
+                 groupName
+      }
+    }
+
+    // Verify the admin is present for the group (and is an admin of the group)
+    const ownerUserGroupMember = await
+            this.userGroupMemberModel.getByUniqueKey(
+              prisma,
+              userGroup.id,
+              ownerUserProfileId)
+
+    if (ownerUserGroupMember == null) {
+
+      return {
+        status: false,
+        message: `Admin: ${ownerUserProfileId} not found for group: ` +
+                 groupName
+      }
+    }
+
+    if (ownerUserGroupMember.isGroupAdmin === false) {
+
+      return {
+        status: false,
+        message: `Owner: ${ownerUserProfileId} is not an admin for group: ` +
+                 groupName
+      }
+    }
+
+    // Return OK
+    return {
+      status: true
+    }
+  }
+}

package/src/services/utils/field-naming-service.ts

@@ -0,0 +1,78 @@
+export class FieldNamingService {
+
+  // Consts
+  clName = 'FieldNamingService'
+
+  // Code
+  getAsKey(name: string) {
+
+    // Trim leading/trailing spaces
+    let key = name.trim()
+
+    // Replace spaces with hyphens
+    key = key.replace(/\s+/g, '-')
+
+    // Remove any character that is not A-Z, a-z, 0-9, hyphen, or underscore
+    key = key.replace(/[^A-Za-z0-9-_]/g, '')
+
+    return key
+  }
+
+  validateKey(
+    key: string,
+    label: string) {
+
+    // Key must be at least 4 chars long (helps reserve short names in the URL)
+    if (key.length < 4) {
+      return {
+        status: false,
+        message: `The ${label} is too short (4+ characters)`
+      }
+    }
+
+    // Return
+    return {
+      status: true
+    }
+  }
+
+  validateName(
+    name: string,
+    label: string) {
+
+    // Null/undefined check
+    if (name == null) {
+      return {
+        status: false,
+        message: `The ${label} is null`
+      }
+    }
+
+    // Trim the workflow name
+    name = name.trim()
+
+    // Name must not start or end with a hypen
+    if (name[0] === '-' ||
+        name[name.length - 1] === '-') {
+      return {
+        status: false,
+        message: `The ${label} can't start or end with a hypen`
+      }
+    }
+
+    // Name must not start or end with an underscore
+    if (name[0] === '_' ||
+        name[name.length - 1] === '_') {
+      return {
+        status: false,
+        message: `The ${label} can't start or end with an underscore`
+      }
+    }
+
+    // Return
+    return {
+      status: true,
+      name: name
+    }
+  }
+}

package/src/services/utils/string-utils-service.ts

@@ -0,0 +1,48 @@
+export class StringUtilsService {
+
+  toNaturalCase(input: string) {
+
+    if (!input) return ''
+
+    // Step 1: Normalize input (handle snake_case, kebab-case, camelCase)
+    let words = input
+      // Insert space before capital letters (camelCase to space-separated)
+      .replace(/([a-z])([A-Z])/g, '$1 $2')
+      // Replace underscores and hyphens with space
+      .replace(/[_\-]+/g, ' ')
+      // Split into words
+      .split(' ')
+
+    // Step 2: Capitalize each word, but keep acronyms (like TV, AI) in uppercase
+    return words
+      .map((word: string) => {
+        if (word.length <= 2 && word === word.toUpperCase()) {
+          // likely an acronym: TV, AI, ML
+          return word;
+        }
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+      })
+      .join(' ')
+  }
+
+  getShortLocaleString(date: Date) {
+
+    const tz = date.toLocaleDateString('en', {
+                 day: '2-digit',
+                 timeZoneName: 'short'
+               }).slice(4) 
+
+    return `${date.toLocaleString()} ${tz}`
+  }
+
+  getSnippet(
+    text: string,
+    maxChars: number) {
+
+    if (text.length < maxChars) {
+      return text
+    }
+
+    return text.substring(0, maxChars) + '..'
+  }
+}

package/src/types/errors.ts

@@ -0,0 +1,18 @@
+export class CustomError extends Error {
+
+  name = 'CustomError'
+
+  constructor(message: string) {
+    super(message)
+    this.name = 'CustomError'
+    Error.captureStackTrace?.(this, CustomError)
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+    }
+  }
+}

package/src/types/user-types.ts

@@ -0,0 +1,19 @@
+export class SereneCoreServerTypes {
+
+  // Statuses
+  static activeStatus = 'A'
+  static newStatus = 'A'
+
+  // Names
+  static credits = 'Credits'
+
+  // Paid/free pricing tiers
+  static free = 'free'
+  static paid = 'paid'
+}
+
+export class UserTypes {
+
+  static botRoleOwnerType = 'B'
+  static humanRoleOwnerType = 'H'
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2023",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",               // Compiled files go here
+    "declaration": true,            // Generate .d.ts types for consumers
+    "strict": true,                 // Strict type checking
+    "esModuleInterop": true,        // Allow default imports from CommonJS
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/prisma/*": ["./prisma/generated/prisma/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+}