Class UpdateManager

constructor

• new UpdateManager(store?: Store): UpdateManager

  Parameters

  • Optionalstore: Store

    The quadstore to store data and metadata. Created if not passed.

  Returns UpdateManager

fps

ifps

ns

patchControl

store

addDownstreamChangeListener

• addDownstreamChangeListener(doc: NamedNode, listener: any): void

  Parameters

  • doc: NamedNode
  • listener: any

  Returns void

anonymize

• anonymize(obj: any): any

  Parameters

  • obj: any

  Returns any

anonymizeNT

• anonymizeNT(stmt: Quad): string

  Parameters

  • stmt: Quad

  Returns string

checkEditable

• checkEditable(
      uri: string | NamedNode,
      kb?: Store,
  ): Promise<undefined | string | boolean>

  Tests whether a file is editable. If the file has a specific annotation that it is machine written, for safety, it is editable (this doesn't actually check for write access) If the file has wac-allow and accept patch headers, those are respected. and local write access is determined by those headers. This async version not only looks at past HTTP requests, it also makes new ones if necessary.

  Parameters

  • uri: string | NamedNode
  • Optionalkb: Store

  Returns Promise<undefined | string | boolean>

  The method string N3PATCH or SPARQL or DAV or LOCALFILE or false if known, undefined if not known.

clearUpstreamCount

• clearUpstreamCount(doc: NamedNode): void

  We want to start counting websocket notifications to distinguish the ones from others from our own.

  Parameters

  • doc: NamedNode

  Returns void

delete_statement

• delete_statement(
      st:
          | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>
          | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[],
      callbackFunction: CallBackFunction,
  ): void

  Parameters

  • st:
        | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>
        | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[]
  • callbackFunction: CallBackFunction

  Returns void

editable

• editable(uri: string | NamedNode, kb?: Store): undefined | string | boolean

  Tests whether a file is editable. If the file has a specific annotation that it is machine written, for safety, it is editable (this doesn't actually check for write access) If the file has wac-allow and accept patch headers, those are respected. and local write access is determined by those headers. This synchronous version only looks at past HTTP requests, does not make new ones.

  Parameters

  • uri: string | NamedNode
  • Optionalkb: Store

  Returns undefined | string | boolean

  The method string SPARQL or DAV or LOCALFILE or false if known, undefined if not known.

flagAuthorizationMetadata

• flagAuthorizationMetadata(kb?: Store): void

  Remove from the store HTTP authorization metadata The editable function below relies on copies we have in the store of the results of previous HTTP transactions. However, when the user logs in, then that data misrepresents what would happen if the user tried again.

  Parameters

  • Optionalkb: Store

  Returns void

getUpdatesVia

• getUpdatesVia(doc: NamedNode): null | string

  Parameters

  • doc: NamedNode

  Returns null | string

insert_statement

• insert_statement(st: Quad, callbackFunction: CallBackFunction): void

  Parameters

  • st: Quad
  • callbackFunction: CallBackFunction

  Returns void

isHttpUri

• isHttpUri(uri: string): boolean

  Parameters

  • uri: string

  Returns boolean

nTriples

• nTriples(stmt: any): string

  Parameters

  • stmt: any

  Returns string

patchControlFor

• patchControlFor(doc: NamedNode): any

  Parameters

  • doc: NamedNode

  Returns any

put

• put(
      doc: NamedNode,
      data:
          | string
          | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[],
      contentType: string,
      callback: (
          uri: string,
          ok: boolean,
          errorMessage?: string,
          response?: unknown,
      ) => void,
  ): Promise<void>

  This is suitable for an initial creation of a document.

  Parameters

  • doc: NamedNode
  • data: string | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[]
  • contentType: string
  • callback: (uri: string, ok: boolean, errorMessage?: string, response?: unknown) => void

  Returns Promise<void>

reload

• reload(
      kb: Store,
      doc: docReloadType,
      callbackFunction: (
          ok: boolean,
          message?: string,
          response?: Error | Response,
      ) => void | {},
  ): void

  Reloads a document.

  Fast and cheap, no metadata. Measure times for the document. Load it provisionally. Don't delete the statements before the load, or it will leave a broken document in the meantime.

  Parameters

  • kb: Store
  • doc: docReloadType

    {RDFlibNamedNode}
  • callbackFunction: (ok: boolean, message?: string, response?: Error | Response) => void | {}

  Returns void

reloadAndSync

• reloadAndSync(doc: NamedNode): void

  Parameters

  • doc: NamedNode

  Returns void

requestDownstreamAction

• requestDownstreamAction(doc: NamedNode, action: any): void

  Requests a now or future action to refresh changes coming downstream This is designed to allow the system to re-request the server version, when a websocket has pinged to say there are changes. If the websocket, by contrast, has sent a patch, then this may not be necessary.

  Parameters

  • doc: NamedNode
  • action: any

  Returns void

serialize

• serialize(
      uri: string,
      data:
          | string
          | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[],
      contentType: string,
  ): string

  Parameters

  • uri: string
  • data: string | Quad<Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph>[]
  • contentType: string

  Returns string

  Throws

  On unsupported content type

setRefreshHandler

• setRefreshHandler(doc: NamedNode, handler: any): boolean

  Sets up websocket to listen on

  There is coordination between upstream changes and downstream ones so that a reload is not done in the middle of an upstream patch. If you use this API then you get called when a change happens, and you have to reload the file yourself, and then refresh the UI. Alternative is addDownstreamChangeListener(), where you do not have to do the reload yourself. Do mot mix them.

  kb contains the HTTP metadata from previous operations

  Parameters

  • doc: NamedNode
  • handler: any

  Returns boolean

update

• update(
      deletions: readonly Statement<
          SubjectType,
          PredicateType,
          ObjectType,
          GraphType,
      >[],
      insertions: readonly Statement<
          SubjectType,
          PredicateType,
          ObjectType,
          GraphType,
      >[],
      callback?: (
          uri: undefined | null | string,
          success: boolean,
          errorBody?: string,
          response?: Error | Response,
      ) => void,
      secondTry?: boolean,
      options?: Partial<AutoInitOptions>,
  ): void | Promise<void>

  This high-level function updates the local store if the web is changed successfully. Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause). The why property of each statement must be the same and give the web document to be updated.

  Parameters

  • deletions: readonly Statement<SubjectType, PredicateType, ObjectType, GraphType>[]

    Statement or statements to be deleted.
  • insertions: readonly Statement<SubjectType, PredicateType, ObjectType, GraphType>[]

    Statement or statements to be inserted.
  • Optionalcallback: (
        uri: undefined | null | string,
        success: boolean,
        errorBody?: string,
        response?: Error | Response,
    ) => void

    called as callbackFunction(uri, success, errorbody) OR returns a promise
  • OptionalsecondTry: boolean
  • Optionaloptions: Partial<AutoInitOptions>

    Options for the fetch call

  Returns void | Promise<void>

update_statement

• update_statement(
      statement: Quad,
  ):
      | undefined
      | {
          set_object: (obj: any, callbackFunction: any) => void;
          statement: undefined | Term[];
          statementNT: undefined | string;
          where: string;
      }

  return a statemnet updating function

  This does NOT update the statement. It returns an object which includes function which can be used to change the object of the statement.

  Parameters

  • statement: Quad

  Returns
      | undefined
      | {
          set_object: (obj: any, callbackFunction: any) => void;
          statement: undefined | Term[];
          statementNT: undefined | string;
          where: string;
      }

updateDav

• updateDav(
      doc: Quad_Subject,
      ds: any,
      is: any,
      callbackFunction: any,
      options?: Partial<AutoInitOptions>,
  ): null | Promise<void>

  Parameters

  • doc: Quad_Subject
  • ds: any
  • is: any
  • callbackFunction: any
  • Optionaloptions: Partial<AutoInitOptions>

  Returns null | Promise<void>

updateLocalFile

• updateLocalFile(
      doc: NamedNode,
      ds: any,
      is: any,
      callbackFunction: any,
      options?: Partial<AutoInitOptions>,
  ): void

  Likely deprecated, since this lib no longer deals with browser extension

  Parameters

  • doc: NamedNode
  • ds: any
  • is: any
  • callbackFunction: any
  • Optionaloptions: Partial<AutoInitOptions>

  Returns void

updateMany

• updateMany(
      deletions: readonly Statement<
          SubjectType,
          PredicateType,
          ObjectType,
          GraphType,
      >[],
      insertions?: readonly Statement<
          SubjectType,
          PredicateType,
          ObjectType,
          GraphType,
      >[],
  ): Promise<void[]>

  This high-level function updates the local store iff the web is changed successfully. Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause). The why property of each statement must be the give the web document to be updated. The statements to be deleted and inserted may span more than one web document.

  Parameters

  • deletions: readonly Statement<SubjectType, PredicateType, ObjectType, GraphType>[]

    Statement or statements to be deleted.
  • Optionalinsertions: readonly Statement<SubjectType, PredicateType, ObjectType, GraphType>[]

    Statement or statements to be inserted.

  Returns Promise<void[]>

  a promise