@hamak/ui-store-impl 0.3.0 → 0.4.0

package/src/fs/commands/fs-commands.ts

@@ -0,0 +1,406 @@
+import {
+  DirectoryNode,
+  FileNode,
+  FileSystemNode,
+  FileSystemState,
+  FileContentSchema,
+  fileSystemNodeInitialState,
+  FileSystemNodeState,
+  Holder
+} from '@hamak/ui-store-api';
+import { Pathway } from '@hamak/navigation-utils';
+import { StructureNodeCommand } from './structure-commands';
+import { DataUpdater } from '../utils/data-updater';
+import { produce, current, isDraft, original } from 'immer';
+import { deepEqual } from '../utils/deep-equal';
+
+/**
+ * Base interface for filesystem commands
+ */
+export interface FsCommandBase {
+  name : 'mkdir' | 'set-file' | 'remove' | 'update-file-content' | 'set-file-content'
+  path : string | string[]
+}
+
+/**
+ * Create directory command
+ */
+export interface MkdirCommand extends FsCommandBase{
+  name : 'mkdir'
+  parents? : boolean
+}
+
+/**
+ * Remove file or directory command
+ */
+export interface RemoveCommand extends FsCommandBase{
+  name : 'remove'
+  recursive? : boolean
+}
+
+/**
+ * Set file command (create or update)
+ */
+export interface SetFileCommand extends FsCommandBase{
+  name : 'set-file'
+  content : any
+  schema : FileContentSchema
+  override? : boolean
+  contentIsPresent? : boolean
+}
+
+/**
+ * Update file content with structure command
+ */
+export interface UpdateFileContentCommand extends FsCommandBase{
+  name : 'update-file-content'
+  contentCommand : StructureNodeCommand
+}
+
+/**
+ * Set file content directly
+ */
+export interface SetFileContentCommand extends FsCommandBase{
+  name : 'set-file-content'
+  content : any,
+  fromRemote?: boolean
+}
+
+/**
+ * Union type for all filesystem commands
+ */
+export type FileSystemCommand =
+  | MkdirCommand
+  | RemoveCommand
+  | SetFileCommand
+  | UpdateFileContentCommand
+  | SetFileContentCommand
+
+/**
+ * Convert path to steps array
+ */
+export function pathSteps(path : string | string[]) : string[] {
+  if(Array.isArray(path)){
+    return path
+  }
+
+  return path.split('/').filter(s => s.trim().length > 0)
+}
+
+/**
+ * Get parent path steps
+ */
+export function parentPathSteps(path : string | string[]) : string[] {
+  const steps = pathSteps(path)
+  return steps.length > 0 ? steps.slice(0, steps.length - 1) : steps
+}
+
+/**
+ * Get filesystem node at path
+ */
+export function getFileSystemNode(fsNode: FileSystemNode, path : string | string[]) : FileSystemNode | undefined {
+  const steps = pathSteps(path)
+  let result : FileSystemNode | undefined = fsNode
+  for(let i = 0; i < steps.length; i++) {
+    const step = steps[i]
+    if (result === undefined){
+      return undefined
+    } else if(result.type === 'directory'){
+      result = result.children[step]
+    } else {
+      return undefined
+    }
+  }
+
+  return result
+}
+
+/**
+ * Create a directory node
+ */
+function createDirectoryNode(step: string) : DirectoryNode{
+  return {
+    type: 'directory',
+    state: fileSystemNodeInitialState(),
+    name: step,
+    children: {}
+  };
+}
+
+/**
+ * Create a file node
+ */
+function createFileNode(name: string, content : any, schema : FileContentSchema, state : FileSystemNodeState) : FileNode{
+  return {type: 'file', name, content, schema, state};
+}
+
+/**
+ * FileSystem command handler - executes filesystem operations
+ */
+export class FileSystemCommandHandler {
+  readonly contentCommandHandler = new FileContentCommandHandler()
+
+  execute(state: FileSystemState, command: FileSystemCommand): FileSystemState {
+    switch (command.name) {
+      case 'mkdir': return this.executeMkdir(state, command)
+      case 'set-file': return this.executeSetFile(state, command)
+      case 'update-file-content' : return this.executeContentCommand(state, command)
+      case 'set-file-content' : return this.executeSetContentCommand(state, command)
+      case 'remove': return this.executeRemove(state, command)
+    }
+  }
+
+  private executeMkdir(state: FileSystemState, command : MkdirCommand) : FileSystemState{
+    const {path, parents} = command
+    const steps = pathSteps(path)
+
+    return produce(state, draft => {
+      const {root} = draft
+      let dir = root
+      for(let i = 0; i < steps.length; i++){
+        const step = steps[i]
+        if(i + 1 === steps.length){
+          // Last step is the element to create
+          if(dir.children[step] === undefined){
+            dir.children[step] = createDirectoryNode(step)
+          }
+        }else {
+          let child = dir.children[step]
+          if(child === undefined){
+            if(parents === true){
+              child = createDirectoryNode(step)
+              dir.children[step] = child
+            }else {
+              return
+            }
+          }else if(child.type === 'directory'){
+            dir = child
+          }else {
+            return;
+          }
+
+          dir = child
+        }
+      }
+    })
+  }
+
+
+  private executeRemove(state: FileSystemState, command : RemoveCommand) : FileSystemState{
+    const {path, recursive} = command
+    const steps = pathSteps(path)
+
+    return produce(state, draft => {
+      const {root} = draft
+      const parentDir = getFileSystemNode(root, steps.slice(0, steps.length - 1))
+      if(parentDir === undefined ){
+        return
+      }
+
+      if(parentDir.type === 'directory'){
+        const last = steps[steps.length - 1]
+        const child = parentDir.children[last]
+        if(child?.type === 'directory'
+          && Object.keys(child.children).length > 0
+          && !(recursive === true) ){
+          return;
+        }
+
+        delete parentDir.children[last]
+      }
+    })
+  }
+
+  private executeSetFile(state: FileSystemState, command : SetFileCommand) : FileSystemState{
+    const {path, content, schema, override, contentIsPresent} = command
+    const steps = pathSteps(path)
+
+    return produce(state, draft => {
+      const {root} = draft
+      const parentPath = steps.slice(0, steps.length - 1);
+      const parentDir = getFileSystemNode(root, parentPath)
+      if(parentDir === undefined ){
+        return
+      }
+
+      if(parentDir.type === 'directory'){
+        const last = steps[steps.length - 1]
+        const child = parentDir.children[last]
+        if(child === undefined || override === true){
+          parentDir.children[last] = createFileNode(last, content, schema, fileSystemNodeInitialState(contentIsPresent))
+        } else {
+          console.warn(`File already exists at location`, path)
+        }
+      }else{
+        console.warn(`Parent file is not directory`, parentPath)
+      }
+    })
+  }
+
+
+  private executeContentCommand(state: FileSystemState, command : UpdateFileContentCommand) : FileSystemState{
+    const {path, contentCommand} = command
+
+    return produce(state, draft => {
+      const {root} = draft
+      const fileNode = getFileSystemNode(root, path)
+
+      if(fileNode !== undefined){
+        if(fileNode.type === 'file'){
+          this.contentCommandHandler.execute(fileNode, contentCommand);
+
+          const previousFile = getFileSystemNode(state.root, path)
+          const previousContent = previousFile?.type === "file" ? previousFile.content : undefined
+
+          this.contentMayChange(fileNode);
+        }else{
+          console.warn(`Not a file at location`, path)
+        }
+      }else{
+        console.warn(`No file found at location`, path)
+      }
+
+    })
+  }
+
+
+  private contentMayChange(fileNode: FileNode) {
+    const changed = ! deepEqual(this.original(fileNode.content), this.current(fileNode.content))
+    if(changed){
+      if (fileNode.state === undefined) {
+        fileNode.state = fileSystemNodeInitialState()
+      }
+      fileNode.state.contentHistory.push(this.original(fileNode.content))
+
+      // check compared to memo modification status
+      if (fileNode.state.memo !== undefined) {
+        const memo = fileNode.state.memo
+        memo.modified = !deepEqual(this.current(memo.originalContent), this.current(fileNode.content))
+      }
+    }
+  }
+
+  private executeSetContentCommand(state: FileSystemState, command : SetFileContentCommand) : FileSystemState{
+    const {path, content, fromRemote} = command
+
+    return produce(state, draft => {
+      const {root} = draft
+      const fileNode = getFileSystemNode(root, path)
+
+      if(fileNode !== undefined){
+        if(fileNode.type === 'file'){
+          fileNode.content = content
+          if(fileNode.state === undefined){
+            fileNode.state = fileSystemNodeInitialState(true)
+          }
+          if(fromRemote){
+            fileNode.state.contentLoaded = true
+            if(fileNode.state.memo === undefined){
+              fileNode.state.memo = {originalContent: {value: content}, modified: false}
+            } else {
+              const memo = fileNode.state.memo
+              memo.originalContent = {value: content}
+              memo.modified = false
+            }
+          } else {
+            this.contentMayChange(fileNode)
+          }
+        }else{
+          console.warn(`Not a file at location`, path)
+        }
+      }else{
+        console.warn(`No file found at location`, path)
+      }
+
+    })
+  }
+
+  protected current<T = any>(o : T):T{
+    if(o === null || o === undefined){
+      return o
+    }
+
+    return isDraft(o) ? current(o) : o
+  }
+
+  protected original<T = any>(o : T):T | undefined{
+    if(o === null || o === undefined){
+      return o
+    }
+
+    return isDraft(o) ? original(o) : o
+  }
+}
+
+/**
+ * File content command handler - handles structure commands on file content
+ */
+export class FileContentCommandHandler {
+  readonly updater = new DataUpdater()
+
+  execute(file : FileNode, command: StructureNodeCommand) {
+    switch (command.name) {
+      case 'add-at':{
+        this.executeAdd(file, command)
+      }break
+      case 'insert-at':{
+        this.executeInsert(file, command)
+      }break
+      case 'set-at':{
+        this.executeSet(file, command)
+      } break
+      case 'delete-at': {
+        this.executeDelete(file, command)
+      } break
+      case 'batch-update': {
+        this.executeBatch(file, command)
+      } break
+    }
+  }
+
+  private executeDelete(file : FileNode, command: any) {
+    const {itinerary} = command
+    if (itinerary === undefined) {
+      file.content = undefined
+    }
+
+    const {content} = file
+    this.updater.executeDelete(content, itinerary)
+  }
+
+  private executeSet(file : FileNode, command: any) {
+    const {itinerary, value} = command
+    if (itinerary === undefined) {
+      file.content = value
+    }
+
+    const {content} = file
+    this.updater.executeSet(content, itinerary, value)
+  }
+
+  private executeAdd(file: FileNode, command: any) {
+    const {itinerary, value} = command
+
+    const {content} = file
+    this.updater.executeAdd(content, itinerary, value)
+  }
+
+  private executeInsert(file: FileNode, command: any) {
+    const {itinerary, value} = command
+    if (itinerary === undefined) {
+      return
+    }
+
+    const {content} = file
+    this.updater.executeInsert(content, itinerary, value)
+  }
+
+  /**
+   * Executes a batch of commands, rebasing each on previous mutations.
+   */
+  public executeBatch(file: FileNode, command: any): void {
+    const { content } = file;
+    this.updater.executeBatch(content, command);
+  }
+
+}

package/src/fs/commands/structure-commands.ts

@@ -0,0 +1,105 @@
+import { Itinerary, StackElement } from '@hamak/navigation-utils';
+
+/**
+ * Base interface for structure node commands
+ */
+export interface StructureNodeCommandBase {
+  name: "add-at" | "set-at" | "delete-at" | 'insert-at' | "batch-update"
+}
+
+/**
+ * Base interface for unitary (single operation) commands
+ */
+export interface UnitaryStructureNodeCommandBase extends StructureNodeCommandBase {
+  name: "add-at" | "set-at" | "delete-at" | 'insert-at'
+  itinerary: Itinerary
+}
+
+/**
+ * Base interface for commands that insert/update values
+ */
+export interface StructureNodeUpsertCommandBase extends UnitaryStructureNodeCommandBase{
+  name: "add-at" | "set-at" | 'insert-at'
+  prototypes? : StackElement<any>
+}
+
+/**
+ * Add a value at the specified itinerary
+ */
+export interface AddStructureNodeCommand extends StructureNodeUpsertCommandBase {
+  name: "add-at"
+  value: any
+}
+
+/**
+ * Insert a value at the specified position
+ */
+export interface InsertStructureNodeCommand extends StructureNodeUpsertCommandBase {
+  name: "insert-at"
+  value: any
+}
+
+/**
+ * Set a value at the specified itinerary
+ */
+export interface SetStructureNodeCommand extends StructureNodeUpsertCommandBase {
+  name: "set-at"
+  value: any
+}
+
+/**
+ * Delete a value at the specified itinerary
+ */
+export interface DeleteStructureNodeCommand extends UnitaryStructureNodeCommandBase {
+  name: "delete-at"
+}
+
+/**
+ * Batch update multiple operations
+ */
+export interface BatchUpdateStructureNodeCommand extends StructureNodeCommandBase {
+  name: "batch-update"
+  autoRebase?: boolean
+  commands: UnitaryStructureNodeCommand[]
+}
+
+/**
+ * Union type for unitary structure node commands
+ */
+export type UnitaryStructureNodeCommand =
+  | AddStructureNodeCommand
+  | InsertStructureNodeCommand
+  | SetStructureNodeCommand
+  | DeleteStructureNodeCommand
+
+/**
+ * Union type for all structure node commands
+ */
+export type StructureNodeCommand = UnitaryStructureNodeCommand | BatchUpdateStructureNodeCommand
+
+/**
+ * Helper class for creating structure node commands
+ */
+export class StructureNodeCommandHelper {
+  addNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : AddStructureNodeCommand{
+    return {name:'add-at', itinerary, value, prototypes}
+  }
+
+  insertNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : InsertStructureNodeCommand{
+    return {name:'insert-at', itinerary, value, prototypes}
+  }
+
+  setNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : SetStructureNodeCommand{
+    return {name:'set-at', itinerary, value, prototypes}
+  }
+
+  deleteNode(itinerary : Itinerary) : DeleteStructureNodeCommand{
+    return {name:'delete-at', itinerary}
+  }
+
+  batchUpdate(commands : UnitaryStructureNodeCommand[], autoRebase = false) : BatchUpdateStructureNodeCommand{
+    return {name:'batch-update', commands, autoRebase}
+  }
+}
+
+export const structs = new StructureNodeCommandHelper()

package/src/fs/core/fs-adapter.ts

@@ -0,0 +1,180 @@
+import { Action, createSelector } from '@reduxjs/toolkit';
+import {
+  FileSystemCommand,
+  FileSystemCommandHandler,
+  pathSteps
+} from '../commands/fs-commands';
+import {
+  FileSystemNode,
+  fileSystemNodeInitialState,
+  FileSystemState,
+  FileContentSchema,
+  FileSystemNodeActionParams,
+  Selector
+} from '@hamak/ui-store-api';
+import { StructureNodeCommand } from '../commands/structure-commands';
+
+/**
+ * Action interface for filesystem operations
+ */
+export interface FileSystemNodeAction extends Action {
+  command: FileSystemCommand
+}
+
+/**
+ * Factory function to create a FileSystemAdapter
+ */
+export function createFileSystemAdapter(sliceName: string) {
+  return new FileSystemAdapter(sliceName)
+}
+
+/**
+ * Filesystem reducer function type
+ */
+export type FileSystemNodeReducerFn = (state: FileSystemState, action: Action) => FileSystemState
+
+/**
+ * FileSystemAdapter - Manages Redux state for virtual filesystem
+ */
+export class FileSystemAdapter {
+  readonly actions: FileSystemNodeActions
+  readonly commandHandler: FileSystemCommandHandler
+  readonly reducer: FileSystemNodeReducerFn
+
+  public constructor(public readonly sliceName: string) {
+    this.actions = new FileSystemNodeActions(sliceName)
+    this.commandHandler = new FileSystemCommandHandler()
+
+    this.reducer = (state= this.getInitialState(), action) => {
+      if (this.actions.isFileSystemNodeAction(action)) {
+        return this.commandHandler.execute(state, action.command)
+      }
+
+      return state
+    }
+  }
+
+  getInitialState(): FileSystemState {
+    return {root:{type: 'directory', name:'', children:{}, state: fileSystemNodeInitialState()}}
+  }
+
+  getActions() {
+    return this.actions
+  }
+
+  getReducer(extraReducers?: FileSystemNodeReducerFn): FileSystemNodeReducerFn {
+    if (extraReducers === undefined) {
+      return this.reducer
+    }
+
+    return (state, action) => this.reducer(extraReducers(state, action), action)
+  }
+
+  createSelector<S>(fileSystemSelector: Selector<S, FileSystemState | undefined>, path : string | string[]) : Selector<S, FileSystemNode | undefined>{
+    const rootSelector = createSelector(fileSystemSelector, fs => fs?.root)
+    const steps = pathSteps(path)
+    if(steps === undefined || steps.length === 0){
+      return rootSelector
+    }
+
+    return steps.reduce((acc, step) => {
+      return createSelector(acc, o => {
+        if(o === undefined || o.type === 'file'){
+          return o
+        }else {
+          return o.children[step]
+        }
+      })
+    }, rootSelector as Selector<S, FileSystemNode | undefined>)
+  }
+}
+
+/**
+ * FileSystemNodeActions - Action creators for filesystem operations
+ */
+export class FileSystemNodeActions {
+  private readonly _mkdirType: string;
+  private readonly _setFileType: string;
+  private readonly _removeType: string;
+  private readonly _updateFileContentType: string;
+  private readonly _setFileContentType: string;
+  private actionTypeSet: Set<string>
+
+  constructor(public sliceName: string) {
+    this._mkdirType = `${this.sliceName}/createDirectoryNode`
+    this._setFileType = `${this.sliceName}/createFileNode`
+    this._removeType = `${this.sliceName}/removeNode`
+    this._updateFileContentType = `${this.sliceName}/updateFileContent`
+    this._setFileContentType = `${this.sliceName}/setFileContent`
+
+    this.actionTypeSet = new Set([
+      this._mkdirType,
+      this._setFileType,
+      this._removeType,
+      this._updateFileContentType,
+      this._setFileContentType
+    ])
+  }
+
+  get mkdirType(): string {
+    return this._mkdirType;
+  }
+
+  get setFileType(): string {
+    return this._setFileType;
+  }
+
+  get removeType(): string {
+    return this._removeType;
+  }
+
+  get updateFileContentType(): string {
+    return this._updateFileContentType;
+  }
+
+  get setFileContentType(): string {
+    return this._setFileContentType;
+  }
+
+  isFileSystemNodeAction(action: Action): action is FileSystemNodeAction {
+    return this.actionTypeSet.has(action.type)
+  }
+
+  public mkdir(path: string | string[], parents?:boolean): FileSystemNodeAction {
+    return {
+      type: this.mkdirType,
+      command: {name : 'mkdir', path, parents}
+    }
+  }
+
+  public setFile(path: string | string[], content:any, schema : FileContentSchema, params : FileSystemNodeActionParams = {override: true, contentIsPresent:true}): FileSystemNodeAction {
+    const {override, contentIsPresent} = params
+    return {
+      type: this.setFileType,
+      command: {name: 'set-file', path, content, schema, override, contentIsPresent}
+    }
+  }
+
+  public updateFileContent(path: string | string[], contentCommand : StructureNodeCommand ): FileSystemNodeAction {
+    return {
+      type: this.updateFileContentType,
+      command: {name: 'update-file-content', path, contentCommand}
+    }
+  }
+
+  public setFileContent(path: string | string[], content : any, fromRemote = false): FileSystemNodeAction {
+    return {
+      type: this.setFileContentType,
+      command: {name: 'set-file-content', path, content, fromRemote}
+    }
+  }
+
+
+  public removeNode(path : string | string[], recursive? : boolean): FileSystemNodeAction {
+    return {
+      type: this.removeType,
+      command: {name: 'remove', path, recursive}
+    }
+  }
+
+}