Store function tests wrong directory for empty status

[j-simmons-phd]

The store function includes a step to verify the target directory for storing is empty before it serializes data to the filesystem. The current implementation checks the specified working directory when it should check the ultimate target directory based on specified working directory and the element path.

[AlexandriaLittle]

Does this only matter when the element path points to an object or also when the path points to a list or similar? Should target directory be target path?

For example:
If the element path is simple and points to a list, the directory that the list is in is the working directory, and that should not be tested to check if it's empty, as it is expected to at least have listElementName.yaml.

Is the intent such that the target destination where the file will be written should not have that exact file there? Should we be testing for whether the target path exists?

[AlexandriaLittle]

Proposed path forward:

• Replace elementName with elementPath
• Rewrite & add new tests to accept elementPath and ensure that the elementPaths actually work
  1. targetPath = workingDir + elementPath
  2. test that targetPath does not exist, not check for empty directories
• Move elementPath related functions from load to utils

[j-simmons-phd]

Does this only matter when the element path points to an object or also when the path points to a list or similar? Should target directory be target path?

The fundamental assumption is that the store function is the sole "actor" responsible for creating all content within the directory ultimately being written to, because it is implementing the Create operation of CRUD, which is for adding content which does not yet exist versus adding to existing content (which is a form of the Update operation).

So, what we want is to identify an empty target directory. In the case of an object, the target directory is the directory where _this.yaml and all of its children is written (which is the object directory). In the case of a list, the target directory is the directory where the list.yaml file and all of its children are written (which is the working directory).

For example: If the element path is simple and points to a list, the directory that the list is in is the working directory, and that should not be tested to check if it's empty, as it is expected to at least have listElementName.yaml.

Since the store function should be the sole "actor" to be writing to the target directory, if the working directory already contains a listElementName.yaml then some other "actor" (even if it was a prior call to store) has already placed content here and store should error out.

Is the intent such that the target destination where the file will be written should not have that exact file there? Should we be testing for whether the target path exists?

Therefore, the underlying issue is that we did not consider that there are in fact two cases that must be tested for:

1. target directory == working directory (the list case, which is what we are currently testing for)
2. target directory == object directory within the working directory, which may not exist yet (inherently empty), it may exist and be empty (still should be ok), and may exist but be non-empty (not ok).

[AlexandriaLittle]

Per discussion in today's meeting:

• Primarily concerned with refactoring code in store.ts lines 205-219
• Move test for directory emptiness from exported store() function into newly refactored code above
• Rework relevant error codes to reflect target directory vs working directory
• Write/refactor existing tests to cover the below decision tree
• store() shall only check for a valid working directory and a valid element name

Decision tree as follows:

• Is this element a list (Array)?
  • Yes
    • Is the target directory empty? (In this case, target dir == working dir)
      • Yes - then continue as normal
      • No - then error for nonempty directory
  • No - assuming this is an object
• Is this element an object (Dictionary)?
  • Yes
    • Determine target directory from element
    • Does the target directory already exist?
      • Yes
        • Is the directory empty?
          • Yes - then continue as normal
          • No - then error for nonempty directory
      • No
        • Create a new directory with that name
  • No - (this case is not covered as there are only lists and objects)