serene-core-client 0.1.1

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

@@ -0,0 +1,64 @@
+import { getUserPreferencesQuery } from '../../apollo/user-preferences'
+
+export class UserPreferencesService {
+
+  zipCountries = [ 'Philippines',
+                   'United States' ]
+
+  async getByKeys(
+          apolloClient: any,
+          userProfileId: string,
+          category: string,
+          keys: string[]) {
+
+    // GraphQL call to get or create user
+    var results: any = null
+
+    console.log('UserPreferencesService.getByKeys(): ' +
+                `userProfileId: ${userProfileId} category: ${category} ` +
+                `keys: ${keys}`)
+
+    await apolloClient.query({
+      query: getUserPreferencesQuery,
+      variables: {
+        userProfileId: userProfileId,
+        category: category,
+        keys: keys
+      }
+    }).then((result: any) => results = result)
+      .catch((error: any) => {
+        console.log(`error.networkError: ${JSON.stringify(error.networkError)}`)
+      })
+
+    console.log(`results: ${JSON.stringify(results)}`)
+
+    return results.data['getUserPreferences']
+  }
+
+  getZipOrPostalCodeLabel(
+    country: string,
+    billingCountryAsMyCountry: boolean,
+    billingCountry: string) {
+
+    if (this.hasZipInsteadOfPostalCode(
+          country,
+          billingCountryAsMyCountry,
+          billingCountry)) {
+      return 'Zip'
+    } else {
+      return 'Postal code'
+    }
+  }
+
+  hasZipInsteadOfPostalCode(
+    country: string,
+    billingCountryAsMyCountry: boolean,
+    billingCountry: string) {
+
+    if (billingCountryAsMyCountry === true) {
+      return this.zipCountries.includes(country)
+    } else {
+      return this.zipCountries.includes(billingCountry)
+    }
+  }
+}

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

@@ -0,0 +1,310 @@
+import { getCookie, setCookie } from 'cookies-next'
+import { getOrCreateSignedOutUserMutation, getOrCreateUserByEmailMutation, verifySignedInUserProfileIdQuery } from '../../apollo/users'
+import { getSession } from 'next-auth/react'
+
+interface ReqRes {
+  req: any
+  res: any
+}
+
+export class UsersService {
+
+  // Consts
+  clName = 'UsersService'
+  signedInCookieName = 'signedInUserUq'
+  signedOutCookieName = 'signedOutUserUq'
+
+  // Code
+  formatCreateBlankUser(json: any) {
+
+    // Debug
+    const fnName = `${this.clName}.formatCreateBlankUser()`
+
+    // console.log(`${fnName}: json: ` + JSON.stringify(json))
+
+    // Formatting
+    const userRecord = json.createBlankUser
+
+    if (!userRecord) {
+      return null
+    }
+
+    var user = {
+      'id': userRecord
+    }
+
+    return user
+  }
+
+  formatUserById(json: any) {
+
+    // Debug
+    const fnName = `${this.clName}.formatUserById()`
+
+    // console.log(`${fnName}: json: ` + JSON.stringify(json))
+
+    // Formatting
+    const userRecord = json.userById
+
+    if (!userRecord) {
+      return null
+    }
+
+    var user = {
+      'id': userRecord.id
+    }
+
+    return user
+  }
+
+  async getSignedInOrOutUserIdFromCookie(
+    { req, res }: ReqRes,
+    apolloClient: any) {
+
+    const session = await getSession({req: req})
+
+    if (session) {
+      return this.getUserIdFromCookieAndVerify(
+               {req: req, res: res},
+               apolloClient)
+    } else {
+      return this.getSignedOutUserIdFromCookie({req: req, res: res})
+    }
+  }
+
+  getSignedOutUserIdFromCookie(
+    { req, res }: ReqRes) {
+
+    // Debug
+    const fnName = `${this.clName}.getSignedOutUserIdFromCookie()`
+
+    // Get cookie
+    const signedOutIdValue =
+            getCookie(this.signedOutCookieName,
+            { req, res })
+
+    // Debug
+    // console.log(`${fnName}: signedOutIdValue: ${signedOutIdValue}`)
+
+    // Return
+    var id
+
+    if (signedOutIdValue == null) {
+      return null
+    } else {
+      id = signedOutIdValue
+      return id
+    }
+  }
+
+  async getUserIdFromCookieAndVerify(
+          { req, res }: ReqRes,
+          apolloClient: any) {
+
+    // Debug
+    const fnName = `${this.clName}.getUserIdFromCookieAndVerify()`
+
+    // Get signed-in userId
+    const idValue: string | undefined = await
+            getCookie(
+              this.signedInCookieName,
+              { req, res })
+
+    // Debug
+    // console.log(`${fnName}: idValue: ${idValue}`)
+
+    // Set userProfileId if idValue not null
+    var userProfileId: string | null | undefined = undefined
+
+    if (idValue == null) {
+      return null
+    } else {
+      userProfileId = idValue
+    }
+
+    // Verify that the signed-in userId exists
+
+    // GraphQL get or create user
+    var results: any = null
+
+    await apolloClient.query({
+      query: verifySignedInUserProfileIdQuery,
+      variables: {
+        userProfileId: userProfileId
+      }
+    }).then((result: any) => results = result)
+      .catch((error: any) => {
+        console.log(`${fnName}: error.networkError: ` +
+                    JSON.stringify(error.networkError))
+      })
+
+    // For now, if the userId isn't found in the DB, return null.
+    // TODO: return an error message, that the user should clear the browser
+    //       cache and retry.
+    if (results != null) {
+      if (results.data['verifySignedInUserProfileId']) {
+        if (results.data['verifySignedInUserProfileId'] === false) {
+          return null
+        }
+      } else {
+        return null
+      }
+    } else {
+      return null
+    }
+
+    // Return
+    return userProfileId
+  }
+
+  async getOrCreateUser(
+          { req, res }: ReqRes,
+          session: any,
+          apolloClient: any,
+          defaultUserPreferences: any) {
+
+    // Debug
+    const fnName = `${this.clName}.getOrCreateUser()`
+
+    // Cookie values
+    var signedInId: string | null | undefined = ''
+    var signedOutId: string | null | undefined = ''
+
+    if (session) {
+
+      signedInId = await
+        this.getUserIdFromCookieAndVerify(
+          { req, res },
+          apolloClient)
+
+    } else {
+      // Note: don't remove the await (getCookie needs it)
+      signedOutId = await this.getSignedOutUserIdFromCookie({ req, res })
+    }
+
+    // Signed-out get/create user
+    const originalSignedOutId = signedOutId
+
+    if (session) {
+
+      // Debug
+      // console.log(`${fnName}: hasSession: ${!!session} email: ${session.user.email}`)
+
+      // GraphQL call to get or create user
+      var results: any = null
+
+      await apolloClient.mutate({
+        mutation: getOrCreateUserByEmailMutation,
+        variables: {
+          email: session.user.email,
+          defaultUserPreferences: JSON.stringify(defaultUserPreferences)
+        }
+      }).then((result: any) => results = result)
+        .catch((error: any) => {
+          console.log(`${fnName}: error: ${error}`)
+          console.log(`${fnName}: error.networkError: ${JSON.stringify(error.networkError)}`)
+        })
+
+      // Debug
+      // console.log(`${fnName}: results: ` + JSON.stringify(results))
+
+      // Get results
+      const newSignedInUserProfile = results.data['getOrCreateUserByEmail']
+
+      // Update with newly created userProfile record
+      if (signedInId !== newSignedInUserProfile.id) {
+          signedInId = newSignedInUserProfile.id
+
+        // console.log('getOrCreateUser: calling setSignedInUserCookie..')
+        this.setSignedInUserCookie(
+          {req, res},
+          newSignedInUserProfile.id)
+      }
+
+      // Return
+      return newSignedInUserProfile
+    }
+
+    // No session available (signed-out)
+    // If not signed-in/out user cookie
+    if (originalSignedOutId !== signedOutId) {
+
+      this.setSignedOutUserCookie(
+        {req, res},
+        signedOutId)
+    }
+
+    // GraphQL call to get or create userProfile for signed-out user
+    // If a signedOutId exists, but the record doesn't, the DB's signed out
+    // userProfiles could have been cleaned.
+    var results: any = null
+
+    await apolloClient.mutate({
+      mutation: getOrCreateSignedOutUserMutation,
+      variables: {
+        signedOutId: signedOutId,
+        defaultUserPreferences: JSON.stringify(defaultUserPreferences)
+      }
+    }).then((result: any) => results = result)
+      .catch((error: any) => {
+        console.log(`${fnName}: error: ${error}`)
+        console.log(`${fnName}: error.networkError: ${JSON.stringify(error.networkError)}`)
+      })
+
+    // Handle null result
+    if (results == null) {
+
+      const message = `${fnName}: null returned from GraphQL request`
+
+      console.error(message)
+      return null
+    }
+
+    // Debug
+    // console.log(`${fnName}: results: ` + JSON.stringify(results))
+
+    // Get results
+    var signedOutUserProfile: any
+
+    const signedOutUser = results.data['getOrCreateSignedOutUser']
+
+    if (signedOutUser) {
+      signedOutUserProfile = signedOutUser
+      signedOutId = signedOutUserProfile.id
+    }
+
+    // Create cookie for signed-out id
+    this.setSignedOutUserCookie({req, res}, signedOutId)
+
+    // Return
+    // console.log(`${fnName}: returning signed-out user id: ${signedOutId}`)
+
+    return signedOutUserProfile
+  }
+
+  setSignedInUserCookie(
+    { req, res }: ReqRes,
+    id: string) {
+
+    // Set userUq in cookie
+    setCookie(
+      this.signedInCookieName,
+      id,
+      { req,
+        res,
+        maxAge: 60 * 60 * 24 * 30 }) // 30 days
+  }
+
+  setSignedOutUserCookie(
+    { req, res }: ReqRes,
+    id: string | null | undefined) {
+
+    // Set signedOutUserUq in cookie
+    setCookie(
+      this.signedOutCookieName,
+      id,
+      { req,
+        res,
+        maxAge: 60 * 60 * 24 * 30 }) // 30 days
+  }
+}

package/src/services/utils/date.ts

@@ -0,0 +1,6 @@
+const { format } = require('date-fns')
+
+export function timestampToDateTime(timestamp: number) {
+
+  return format(new Date(timestamp * 1), 'PPPPpppp')
+}

package/src/services/utils/functions.ts

@@ -0,0 +1,8 @@
+export function boolFromString(s: string) {
+  if (s === 'true')
+  {
+    return true
+  }
+
+  return false
+}

package/src/services/utils/service.ts

@@ -0,0 +1,12 @@
+export class UtilsService {
+
+  getBaseUrl(url: string) {
+    // Based on: https://stackoverflow.com/a/1420902
+
+    var pathArray = url.split('/')
+    var protocol = pathArray[0]
+    var host = pathArray[2]
+
+    return protocol + '//' + host
+  }
+}

package/src/services/utils/string.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/services/utils/tree.ts

@@ -0,0 +1,88 @@
+// This function assumes that the list has properties id and parentId. There is
+// an assumption that there's only one root node (parentId will be null).
+export class TreeUtilsService {
+
+  // Helper function
+  addChildNodesWithChildrenPropertyName(
+    item: any,
+    parentIdMap: Map<string, any[]>) {
+
+    // Create node. Create a shallow copy of the object to prevent the "Object
+    // is not extensible" error on the next line.
+    var node = { ...item }
+    node.children = []
+
+    // Add child nodes
+    const childItems = parentIdMap.get(node.id)
+
+    // console.log(`.  childItems: ${JSON.stringify(childItems)}`)
+
+    if (childItems !== undefined) {
+      for (const childItem of childItems) {
+
+        const childNode = this.addChildNodesWithChildrenPropertyName(
+                            childItem,
+                            parentIdMap)
+
+        node.children.push(childNode)
+      }
+    }
+
+    return node
+  }
+
+  listToTree(
+    list: any[],
+    childNodesPropertyName: string = 'children') {
+
+    // Convert to maps indexed by id and parentId, also get the root node
+    var node: any = null
+    var idMap = new Map<string, any>()
+    var parentIdMap = new Map<string, any[]>()
+
+    for (const item of list) {
+      idMap.set(item.id, item)
+
+      if (item.parentId === null) {
+        // Root node has parentId of null
+        node = item
+      } else {
+        // Populate parentIdMap except for root node which has parentId of null.
+        // Null can't be an index to a map anyway.
+        var parentItems = parentIdMap.get(item.parentId)
+
+        if (parentItems === undefined) {
+          parentItems = [item]
+        } else {
+          parentItems.push(item)
+        }
+
+        parentIdMap.set(item.parentId, parentItems)
+      }
+    }
+
+    // console.log(`.  parentIdMap: ${JSON.stringify(parentIdMap)}`)
+
+    // Copy the idMap to a new map that tracks which items have yet to be added
+    // to the tree. Remove the root node.
+    var itemsNotAdded = idMap
+
+    if (node === null) {
+      throw 'A root node wasn\'t identified'
+    } else {
+      itemsNotAdded.delete(node.id)
+    }
+
+    // Create the tree
+    if (childNodesPropertyName === 'children') {
+      node = this.addChildNodesWithChildrenPropertyName(
+               node,
+               parentIdMap)
+    } else {
+      throw `Unhandled childNodesPropertyName: ${childNodesPropertyName}`
+    }
+
+    // Return root node
+    return node
+  }
+}

package/src/types/types.ts

@@ -0,0 +1,4 @@
+export class SereneCoreClientTypes {
+
+  static credits = 'Credits'
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "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,
+    "jsx": "react-jsx",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "skipLibCheck": true
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+}