Created a draft of an extended profile service

Prompt: Created 2 docs and pointed copilot to them, one for the best
strategies for working with data in solidos and another to all the problems
I found with the profile mutations. Told it copy the logic in profile-pane for
mutations to solid-logic, extend the profile service and expose these methods.
After that performed many cleanup tasks to simply/cleanup the code even further.

Co-authored-by: GPT-5.6 Luna <gpt-5.6-luna@openai.com>

Author: SharonStrats

package-lock.json

@@ -23,7 +23,7 @@ function isHttpUrl (value: string): boolean {
     return value.startsWith('http://') || value.startsWith('https://')
 }
 
-function isBareOriginUrl (value: string): boolean {
+export function isOriginUrl (value: string): boolean {
     try {
         const parsed = new URL(value)
         return (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
@@ -57,7 +57,7 @@ export async function classifyAccessControlSubject (store: LiveStore, principle:
     const subject = sym(principle)
     let types = store.findTypeURIs(subject)
 
-    if (isBareOriginUrl(principle)) {
+    if (isOriginUrl(principle)) {
         return { kind: 'origin', subjectValue: normalizeOriginUrl(principle) }
     }
 

src/acl/accessControlSubjects.ts

@@ -14,10 +14,26 @@ export { reloadOnIdentityReplaced } from './authSession/identityState'
 export { getSuggestedIssuers } from './issuer/issuerLogic'
 export { createTypeIndexLogic } from './typeIndex/typeIndexLogic'
 export { createDirectoryLogic, DEFAULT_DIRECTORY_CATALOG_URL, DEFAULT_DIRECTORY_SOURCES } from './directory/directoryLogic'
+export { createProfileMutationService } from './profile/profileMutationService'
+export type { BioMutationPlan, BioRow } from './profile/sections/bio/types'
+export type { ContactMutationPlan, ContactPointRow, ContactAddressRow } from './profile/sections/contactInfo/types'
+export type { EducationMutationPlan, EducationRow } from './profile/sections/education/types'
+export type { HeadingMutationPlan, ProfileBasicRow } from './profile/sections/heading/types'
+export type { LanguageMutationPlan } from './profile/sections/languages/mutations'
+export type { LanguageRow } from './profile/sections/languages/types'
+export type { ProjectMutationPlan, ProjectRow } from './profile/sections/projects/types'
+export type { ResumeMutationPlan } from './profile/sections/resume/mutations'
+export type { ResumeRow } from './profile/sections/resume/types'
+export type { SkillMutationPlan } from './profile/sections/skills/mutations'
+export type { SkillRow } from './profile/sections/skills/types'
+export type { SocialMutationPlan, SocialRow } from './profile/sections/social/types'
+export type { MutationOps, RowStatus, RdfStatement } from './profile/sections/shared/types'
+export { isOriginUrl } from './acl/accessControlSubjects'
 export type { AccessControlSubjectKind, AccessControlSubject } from './acl/accessControlSubjects'
 export type { ACLContext, AccessMode, AccessSubject, Authorization, PatchPlan } from './types'
-export type { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic, ChatLogic, DirectoryLogic, DirectoryEntry, DirectorySearchOptions, DirectoryRelationshipLabel, DirectorySource } from './types'
+export type { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic, ProfileLogic, ChatLogic, DirectoryLogic, DirectoryEntry, DirectorySearchOptions, DirectoryRelationshipLabel, DirectorySource, ProfileMutationService } from './types'
 export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
+export { documentDirectoryUri, isAbsoluteHttpUri } from './util/utils'
 
 export {
   solidLogicSingleton, // solidLogicSingleton is exported entirely because it is used in solid-panes

src/index.ts

@@ -2,72 +2,41 @@ import { literal, NamedNode, st, sym } from 'rdflib'
 import { ACL_LINK } from '../acl/aclLogic'
 import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from '../logic/CustomError'
 import * as debug from '../util/debug'
-import { ns as namespace } from '../util/ns'
+import { ns } from '../util/ns'
 import { privateTypeIndexDocument, publicTypeIndexDocument } from '../typeIndex/typeIndexDocuments'
 import { publicTypeIndexAclDocument } from '../typeIndex/typeIndexAclDocuments'
 import { preferencesFileDocument } from './profileDocuments'
 import { ownerOnlyContainerAclDocument } from './profileAclDocuments'
 import { createContainerLogic } from '../util/containerLogic'
-import { differentOrigin, suggestPreferencesFile } from '../util/utils'
+import { differentOrigin, documentDirectoryUri, suggestPreferencesFile } from '../util/utils'
+import { isMissingError } from '../resource/resourceHttp'
 import { ProfileLogic } from '../types'
+import { createProfileMutationService } from './profileMutationService'
 
 export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
-    const ns = namespace
     const containerLogic = createContainerLogic(store)
+    const profileMutationService = createProfileMutationService(store)
     const loadPreferencesInFlight = new Map<string, Promise<NamedNode>>()
     const cachedPreferencesFileByWebId = new Map<string, NamedNode>()
 
-    function isAbsoluteHttpUri(uri: string | null | undefined): boolean {
-        return !!uri && (uri.startsWith('https://') || uri.startsWith('http://'))
-    }
-
-    function docDirUri(node: NamedNode): string | null {
-        const doc = node.doc()
-        const dir = doc.dir()
-        if (dir?.uri && isAbsoluteHttpUri(dir.uri)) return dir.uri
-        const docUri = doc.uri
-        if (!docUri || !isAbsoluteHttpUri(docUri)) return null
-        const withoutFragment = docUri.split('#')[0]
-        const lastSlash = withoutFragment.lastIndexOf('/')
-        if (lastSlash === -1) return null
-        return withoutFragment.slice(0, lastSlash + 1)
-    }
-
     function suggestTypeIndexInPreferences(preferencesFile: NamedNode, filename: string): NamedNode {
-        const dirUri = docDirUri(preferencesFile)
+        const dirUri = documentDirectoryUri(preferencesFile)
         if (!dirUri) throw new Error(`Cannot derive directory for preferences file ${preferencesFile.uri}`)
         return sym(dirUri + filename)
     }
 
-    function isNotFoundError(err: any): boolean {
-        if (err?.response?.status === 404) return true
-        const text = `${err?.message || err || ''}`
-        return text.includes('404') || text.includes('Not Found')
-    }
-
-    async function ensureContainerExists(containerUri: string): Promise<void> {
-        const containerNode = sym(containerUri)
-        try {
-            await store.fetcher.load(containerNode)
-            return
-        } catch (err) {
-            if (!isNotFoundError(err)) throw err
-        }
-        await containerLogic.createContainer(containerUri)
-    }
-
     async function ensureOwnerOnlyAclForSettings(user: NamedNode, preferencesFile: NamedNode): Promise<void> {
-        const dirUri = docDirUri(preferencesFile)
+        const dirUri = documentDirectoryUri(preferencesFile)
         if (!dirUri) throw new Error(`Cannot derive settings directory from ${preferencesFile.uri}`)
-        await ensureContainerExists(dirUri)
+        await containerLogic.ensureContainer(dirUri)
 
         const containerNode = sym(dirUri)
         let aclDocUri: string | undefined
         try {
             await store.fetcher.load(containerNode)
             aclDocUri = store.any(containerNode, ACL_LINK)?.value
         } catch (err) {
-            if (!isNotFoundError(err)) throw err
+            if (!isMissingError(err)) throw err
         }
         if (!aclDocUri) {
             // Fallback for servers/tests where rel=acl is not exposed in mocked headers.
@@ -78,7 +47,7 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
             await store.fetcher.load(aclDoc)
             return
         } catch (err) {
-            if (!isNotFoundError(err)) throw err
+            if (!isMissingError(err)) throw err
         }
 
         await store.fetcher.webOperation('PUT', aclDoc.uri, {
@@ -96,7 +65,7 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
             await store.fetcher.load(publicTypeIndex)
             aclDocUri = store.any(publicTypeIndex, ACL_LINK)?.value
         } catch (err) {
-            if (!isNotFoundError(err)) throw err
+            if (!isMissingError(err)) throw err
         }
         if (!aclDocUri) {
             aclDocUri = `${publicTypeIndex.uri}.acl`
@@ -336,6 +305,7 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
     }
 
     return {
+        ...profileMutationService,
         loadMe,
         getPodRoot,
         getMainInbox,

src/profile/profileLogic.ts

@@ -0,0 +1,63 @@
+import { NamedNode, LiveStore } from 'rdflib'
+import { NotEditableError } from '../logic/CustomError'
+import type { ProfileMutationService } from '../types'
+import { processBioMutations } from './sections/bio/mutations'
+import { processContactInfoMutations } from './sections/contactInfo/mutations'
+import { processEducationMutations } from './sections/education/mutations'
+import { processHeadingMutations } from './sections/heading/mutations'
+import { processLanguageMutations } from './sections/languages/mutations'
+import { processProjectsMutations } from './sections/projects/mutations'
+import { processResumeMutations } from './sections/resume/mutations'
+import { processSkillsMutations } from './sections/skills/mutations'
+import { processSocialMutations } from './sections/social/mutations'
+import type { HeadingMutationPlan } from './sections/heading/types'
+import type { BioMutationPlan } from './sections/bio/types'
+import type { ContactMutationPlan } from './sections/contactInfo/types'
+import type { EducationMutationPlan } from './sections/education/types'
+import type { LanguageMutationPlan } from './sections/languages/mutations'
+import type { LanguageRow } from './sections/languages/types'
+import type { ProjectMutationPlan } from './sections/projects/types'
+import type { ResumeMutationPlan } from './sections/resume/mutations'
+import type { SkillMutationPlan } from './sections/skills/mutations'
+import type { SocialMutationPlan, SocialRow } from './sections/social/types'
+
+export function createProfileMutationService (store: LiveStore): ProfileMutationService {
+  async function prepareProfileDocument (doc: NamedNode): Promise<void> {
+    await store.fetcher.load(doc, { force: true })
+    if (!store.updater.editable(doc)) {
+      throw new NotEditableError(`Cannot edit profile document ${doc.value}`)
+    }
+  }
+
+  async function runProfileSectionMutation<Args extends unknown[]>(
+    subject: NamedNode,
+    mutation: (store: LiveStore, subject: NamedNode, ...args: Args) => Promise<void>,
+    ...args: Args
+  ): Promise<void> {
+    await prepareProfileDocument(subject.doc())
+    await mutation(store, subject, ...args)
+  }
+
+  return {
+    processHeadingMutations: (subject: NamedNode, plan: HeadingMutationPlan) =>
+      runProfileSectionMutation(subject, processHeadingMutations, plan),
+    processContactInfoMutations: (subject: NamedNode, plan: ContactMutationPlan) =>
+      runProfileSectionMutation(subject, processContactInfoMutations, plan),
+    processBioMutations: (subject: NamedNode, plan: BioMutationPlan) =>
+      runProfileSectionMutation(subject, processBioMutations, plan),
+    processEducationMutations: (subject: NamedNode, plan: EducationMutationPlan) =>
+      runProfileSectionMutation(subject, processEducationMutations, plan),
+    processLanguageMutations: (subject: NamedNode, plan: LanguageMutationPlan, orderedRows?: LanguageRow[]) =>
+      runProfileSectionMutation(subject, processLanguageMutations, plan, orderedRows),
+    processProjectsMutations: (subject: NamedNode, plan: ProjectMutationPlan) =>
+      runProfileSectionMutation(subject, processProjectsMutations, plan),
+    processResumeMutations: (subject: NamedNode, plan: ResumeMutationPlan) =>
+      runProfileSectionMutation(subject, processResumeMutations, plan),
+    processSkillsMutations: (subject: NamedNode, plan: SkillMutationPlan) =>
+      runProfileSectionMutation(subject, processSkillsMutations, plan),
+    processSocialMutations: (subject: NamedNode, plan: SocialMutationPlan, orderedRows?: SocialRow[]) =>
+      runProfileSectionMutation(subject, processSocialMutations, plan, orderedRows)
+  }
+}
+
+export type { ProfileMutationService }

src/profile/profileMutationService.ts

@@ -0,0 +1,45 @@
+import { LiveStore, NamedNode } from 'rdflib'
+import { ns } from '../../../util/ns'
+import { BioMutationPlan, BioRow } from './types'
+import { MutationOps } from '../shared/types'
+import { replaceLiteralPredicateStatements, runUpdateTransport } from '../shared/rdfMutationHelpers'
+import { logAndThrowMutationError } from '../shared/mutationErrors'
+import { bioUpdatesFailedMessageText, updaterUnsupportedStoreErrorMessageText } from '../../texts'
+
+async function mutateBioEntry(store: LiveStore, subject: NamedNode, bioOps: MutationOps<BioRow>) {
+  const doc = subject.doc()
+  const deletions: any[] = []
+  const insertions: any[] = []
+
+  const applyBasics = (bio: BioRow, clearAll = false) => {
+    const data = clearAll
+      ? {
+          description: '',
+        }
+      : bio
+
+    replaceLiteralPredicateStatements(store, subject, ns.vcard('note'), doc, deletions, insertions, data.description)
+  }
+
+  const removeBio = bioOps.remove[0]
+  const updateBio = bioOps.update[0]
+  const createBio = bioOps.create[0]
+
+  const selectedBio = updateBio || createBio || removeBio
+  if (selectedBio) {
+    applyBasics(selectedBio, Boolean(removeBio && !updateBio && !createBio))
+  }
+
+  await runUpdateTransport(store, doc, deletions, insertions, {
+    unsupportedMessage: updaterUnsupportedStoreErrorMessageText,
+    failureMessage: bioUpdatesFailedMessageText,
+  })
+}
+
+export async function processBioMutations(store: LiveStore, subject: NamedNode, mutationPlan: BioMutationPlan) {
+  try {
+    await mutateBioEntry(store, subject, mutationPlan)
+  } catch (error) {
+    logAndThrowMutationError(error)
+  }
+} 

src/profile/sections/bio/mutations.ts

@@ -0,0 +1,18 @@
+import { Node } from 'rdflib'
+import { MutationOps } from '../shared/types'
+import { RowStatus } from '../shared/types'
+
+export interface BioFields {
+  description?: string
+}
+
+export interface BioDetails extends BioFields {
+  entryNode: Node
+}
+
+export interface BioRow extends BioFields {
+  entryNode: string
+  status: RowStatus
+}
+
+export type BioMutationPlan = MutationOps<BioRow>