@elek-io/core 0.5.4 → 0.7.0

package/dist/node/index.node.js

@@ -136,13 +136,13 @@ var baseFileSchema = z2.object({
    */
   id: uuidSchema.readonly(),
   /**
-   * The timestamp of the file being created is set by the service of "objectType" while creating it
+   * The datetime of the file being created is set by the service of "objectType" while creating it
    */
-  created: z2.number().readonly(),
+  created: z2.string().datetime().readonly(),
   /**
-   * The timestamp of the file being updated is set by the service of "objectType" while updating it
+   * The datetime of the file being updated is set by the service of "objectType" while updating it
    */
-  updated: z2.number().nullable()
+  updated: z2.string().datetime().nullable()
 });
 var baseFileWithLanguageSchema = baseFileSchema.extend({
   /**
@@ -444,7 +444,7 @@ var resolvedValueSchema = z4.union([
 function getValueContentSchemaFromDefinition(definition) {
   switch (definition.valueType) {
     case ValueTypeSchema.Enum.boolean:
-      return getBooleanValueContentSchema(definition);
+      return getBooleanValueContentSchema();
     case ValueTypeSchema.Enum.number:
       return getNumberValueContentSchema(definition);
     case ValueTypeSchema.Enum.string:
@@ -458,7 +458,7 @@ function getValueContentSchemaFromDefinition(definition) {
       );
   }
 }
-function getBooleanValueContentSchema(definition) {
+function getBooleanValueContentSchema() {
   return z4.boolean();
 }
 function getNumberValueContentSchema(definition) {
@@ -662,7 +662,7 @@ var gitCommitSchema = z8.object({
   hash: z8.string(),
   message: z8.string(),
   author: gitSignatureSchema,
-  timestamp: z8.number(),
+  datetime: z8.string().datetime(),
   tag: z8.string().nullable()
 });
 var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
@@ -731,7 +731,7 @@ var gitTagSchema = z9.object({
   id: uuidSchema,
   message: z9.string(),
   author: gitSignatureSchema,
-  timestamp: z9.number()
+  datetime: z9.string().datetime()
 });
 var createGitTagSchema = gitTagSchema.pick({
   message: true
@@ -1082,6 +1082,12 @@ async function files(path, extension) {
 
 // src/service/AbstractCrudService.ts
 var AbstractCrudService = class {
+  type;
+  options;
+  /**
+   * Dynamically generated git messages for operations
+   */
+  gitMessage;
   /**
    * Do not instantiate directly as this is an abstract class
    */
@@ -1161,7 +1167,7 @@ var AbstractCrudService = class {
       possibleFiles.map(async (possibleFile) => {
         const fileNameArray = possibleFile.name.split(".");
         const fileReference = {
-          id: fileNameArray[0],
+          id: fileNameArray[0] || "",
           language: fileNameArray.length === 3 ? fileNameArray[1] : void 0,
           extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
         };
@@ -1177,107 +1183,34 @@ var AbstractCrudService = class {
 };
 
 // src/service/AssetService.ts
-import Fs3 from "fs-extra";
-import IsSvg from "is-svg";
+import { fileTypeFromFile } from "file-type";
+import Fs2 from "fs-extra";
+import isSvg from "is-svg";
 
 // src/util/shared.ts
-import slugify from "slugify";
+import slugify from "@sindresorhus/slugify";
 import { v4 as generateUuid } from "uuid";
-var Slugify = slugify.default || slugify;
 function uuid() {
   return generateUuid();
 }
-function currentTimestamp() {
-  return Math.floor(Date.now() / 1e3);
+function datetime(value) {
+  if (!value) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return new Date(value).toISOString();
 }
 function slug(string) {
-  return Slugify(string, {
-    replacement: "-",
-    // replace spaces with replacement character, defaults to `-`
-    remove: void 0,
-    // remove characters that match regex, defaults to `undefined`
-    lower: true,
-    // convert to lower case, defaults to `false`
-    strict: true
-    // strip special characters except replacement, defaults to `false`
+  return slugify(string, {
+    separator: "-",
+    lowercase: true,
+    decamelize: true
   });
 }
 
-// src/service/JsonFileService.ts
-import Fs2 from "fs-extra";
-var JsonFileService = class extends AbstractCrudService {
-  constructor(options) {
-    super(serviceTypeSchema.Enum.JsonFile, options);
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Creates a new file on disk. Fails if path already exists
-   *
-   * @param data Data to write into the file
-   * @param path Path to write the file to
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async create(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await Fs2.writeFile(path, string, {
-      flag: "wx",
-      encoding: "utf8"
-    });
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  /**
-   * Reads the content of a file on disk. Fails if path does not exist
-   *
-   * @param path Path to read the file from
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async read(path, schema) {
-    if (this.cache.has(path)) {
-      return this.cache.get(path);
-    }
-    const data = await Fs2.readFile(path, {
-      flag: "r",
-      encoding: "utf8"
-    });
-    const json = this.deserialize(data);
-    const parsedData = schema.parse(json);
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  /**
-   * Overwrites an existing file on disk
-   *
-   * @todo Check how to error out if the file does not exist already
-   *
-   * @param data Data to write into the file
-   * @param path Path to the file to overwrite
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
-   */
-  async update(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await Fs2.writeFile(path, string, {
-      flag: "w",
-      encoding: "utf8"
-    });
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  serialize(data) {
-    return JSON.stringify(data, null, this.options.file.json.indentation);
-  }
-  deserialize(data) {
-    return JSON.parse(data);
-  }
-};
-
 // src/service/AssetService.ts
 var AssetService = class extends AbstractCrudService {
+  jsonFileService;
+  gitService;
   constructor(options, jsonFileService, gitService) {
     super(serviceTypeSchema.Enum.Asset, options);
     this.jsonFileService = jsonFileService;
@@ -1303,14 +1236,14 @@ var AssetService = class extends AbstractCrudService {
       ...props,
       objectType: "asset",
       id,
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null,
       extension: fileType.extension,
       mimeType: fileType.mimeType,
       size
     };
     try {
-      await Fs3.copyFile(props.filePath, assetPath);
+      await Fs2.copyFile(props.filePath, assetPath);
       await this.jsonFileService.create(
         assetFile,
         assetFilePath,
@@ -1352,7 +1285,7 @@ var AssetService = class extends AbstractCrudService {
     const assetFile = {
       ...prevAssetFile,
       ...props,
-      updated: currentTimestamp()
+      updated: datetime()
     };
     if (props.newFilePath) {
       const fileType = await this.getSupportedFileTypeOrThrow(
@@ -1371,8 +1304,8 @@ var AssetService = class extends AbstractCrudService {
         props.language,
         fileType.extension
       );
-      await Fs3.remove(prevAssetPath);
-      await Fs3.copyFile(props.newFilePath, assetPath);
+      await Fs2.remove(prevAssetPath);
+      await Fs2.copyFile(props.newFilePath, assetPath);
       assetFile.extension = fileType.extension;
       assetFile.mimeType = fileType.mimeType;
       assetFile.size = size;
@@ -1403,8 +1336,8 @@ var AssetService = class extends AbstractCrudService {
       props.language,
       props.extension
     );
-    await Fs3.remove(assetPath);
-    await Fs3.remove(assetFilePath);
+    await Fs2.remove(assetPath);
+    await Fs2.remove(assetFilePath);
     await this.gitService.add(projectPath, [assetFilePath, assetPath]);
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
@@ -1453,7 +1386,7 @@ var AssetService = class extends AbstractCrudService {
    * @param path Path of the Asset to get the size from
    */
   async getAssetSize(path) {
-    return (await Fs3.stat(path)).size;
+    return (await Fs2.stat(path)).size;
   }
   /**
    * Creates an Asset from given AssetFile
@@ -1481,17 +1414,16 @@ var AssetService = class extends AbstractCrudService {
    * @param filePath Path to the file to check
    */
   async getSupportedFileTypeOrThrow(filePath) {
-    const fileSize = (await Fs3.stat(filePath)).size;
+    const fileSize = (await Fs2.stat(filePath)).size;
     if (fileSize / 1e3 <= 500) {
-      const fileBuffer = await Fs3.readFile(filePath);
-      if (IsSvg(fileBuffer.toString()) === true) {
+      const fileBuffer = await Fs2.readFile(filePath);
+      if (isSvg(fileBuffer.toString()) === true) {
         return {
           extension: supportedAssetExtensionSchema.Enum.svg,
           mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
         };
       }
     }
-    const { fileTypeFromFile } = await import("file-type");
     const fileType = await fileTypeFromFile(filePath);
     const result = supportedAssetTypeSchema.parse({
       extension: fileType?.ext,
@@ -1502,454 +1434,861 @@ var AssetService = class extends AbstractCrudService {
 };
 
 // src/service/CollectionService.ts
-import Fs4 from "fs-extra";
-
-// src/service/GitService.ts
-import { GitProcess } from "dugite";
-import { EOL as EOL2 } from "os";
-import PQueue from "p-queue";
-
-// src/service/GitTagService.ts
-import { EOL } from "os";
-var GitTagService = class extends AbstractCrudService {
-  constructor(options, git) {
-    super(serviceTypeSchema.Enum.GitTag, options);
-    this.git = git;
+import Fs3 from "fs-extra";
+var CollectionService = class extends AbstractCrudService {
+  jsonFileService;
+  gitService;
+  constructor(options, jsonFileService, gitService) {
+    super(serviceTypeSchema.Enum.Collection, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
   }
   /**
-   * Creates a new tag
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
+   * Creates a new Collection
    */
   async create(props) {
-    createGitTagSchema.parse(props);
+    createCollectionSchema.parse(props);
     const id = uuid();
-    let args = ["tag", "--annotate", id];
-    if (props.hash) {
-      args = [...args, props.hash];
-    }
-    args = [...args, "-m", props.message];
-    await this.git(props.path, args);
-    const tag = await this.read({ path: props.path, id });
-    return tag;
+    const projectPath = pathTo.project(props.projectId);
+    const collectionPath = pathTo.collection(props.projectId, id);
+    const collectionFilePath = pathTo.collectionFile(props.projectId, id);
+    const collectionFile = {
+      ...props,
+      objectType: "collection",
+      id,
+      slug: {
+        singular: slug(props.slug.singular),
+        plural: slug(props.slug.plural)
+      },
+      created: datetime(),
+      updated: null
+    };
+    await Fs3.ensureDir(collectionPath);
+    await this.jsonFileService.create(
+      collectionFile,
+      collectionFilePath,
+      collectionFileSchema
+    );
+    await this.gitService.add(projectPath, [collectionFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return collectionFile;
   }
   /**
-   * Returns a tag by ID
-   *
-   * Internally uses list() but only returns the tag with matching ID.
+   * Returns a Collection by ID
    */
   async read(props) {
-    readGitTagSchema.parse(props);
-    const tags = await this.list({ path: props.path });
-    const tag = tags.list.find((tag2) => {
-      return tag2.id === props.id;
-    });
-    if (!tag) {
-      throw new GitError(
-        `Provided tag with UUID "${props.id}" did not match any known tags`
-      );
-    }
-    return tag;
+    readCollectionSchema.parse(props);
+    const collection = await this.jsonFileService.read(
+      pathTo.collectionFile(props.projectId, props.id),
+      collectionFileSchema
+    );
+    return collection;
   }
   /**
-   * Updating a git tag is not supported.
-   * Please delete the old and create a new one
+   * Updates given Collection
    *
-   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
+   * @todo finish implementing checks for FieldDefinitions and extract methods
+   *
+   * @param projectId   Project ID of the collection to update
+   * @param collection  Collection to write to disk
+   * @returns           An object containing information about the actions needed to be taken,
+   *                    before given update can be executed or void if the update was executed successfully
    */
-  async update() {
-    throw new Error(
-      "Updating a git tag is not supported. Please delete the old and create a new one"
+  async update(props) {
+    updateCollectionSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
+    const prevCollectionFile = await this.read(props);
+    const collectionFile = {
+      ...prevCollectionFile,
+      ...props,
+      updated: datetime()
+    };
+    await this.jsonFileService.update(
+      collectionFile,
+      collectionFilePath,
+      collectionFileSchema
     );
+    await this.gitService.add(projectPath, [collectionFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return collectionFile;
   }
   /**
-   * Deletes a tag
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+   * Deletes given Collection (folder), including it's items
    *
-   * @param path  Path to the repository
-   * @param id    UUID of the tag to delete
+   * The Fields that Collection used are not deleted.
    */
   async delete(props) {
-    deleteGitTagSchema.parse(props);
-    const args = ["tag", "--delete", props.id];
-    await this.git(props.path, args);
+    deleteCollectionSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const collectionPath = pathTo.collection(props.projectId, props.id);
+    await Fs3.remove(collectionPath);
+    await this.gitService.add(projectPath, [collectionPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
-  /**
-   * Gets all local tags or filter them by pattern
-   *
-   * They are sorted by authordate of the commit, not the timestamp the tag is created.
-   * This ensures tags are sorted correctly in the timeline of their commits.
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
-   */
   async list(props) {
-    listGitTagsSchema.parse(props);
-    let args = ["tag", "--list"];
-    args = [
-      ...args,
-      "--sort=-*authordate",
-      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
-    ];
-    const result = await this.git(props.path, args);
-    const noEmptyLinesArr = result.stdout.split(EOL).filter((line) => {
-      return line.trim() !== "";
-    });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        id: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        timestamp: parseInt(lineArray[4])
-      };
-    });
-    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
+    listCollectionsSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const collectionReferences = await this.listReferences(
+      objectTypeSchema.Enum.collection,
+      props.projectId
+    );
+    const partialCollectionReferences = collectionReferences.slice(
+      offset,
+      limit
+    );
+    const collections = await returnResolved(
+      partialCollectionReferences.map((reference) => {
+        return this.read({
+          projectId: props.projectId,
+          id: reference.id
+        });
+      })
+    );
     return {
-      total: gitTags.length,
-      limit: 0,
-      offset: 0,
-      list: gitTags
+      total: collectionReferences.length,
+      limit,
+      offset,
+      list: collections
     };
   }
-  /**
-   * Returns the total number of tags inside given repository
-   *
-   * Internally uses list(), so do not use count()
-   * in conjuncion with it to avoid multiple git calls.
-   *
-   * @param path Path to the repository
-   */
   async count(props) {
-    countGitTagsSchema.parse(props);
-    const gitTags = await this.list({ path: props.path });
-    return gitTags.total;
+    countCollectionsSchema.parse(props);
+    const count = (await this.listReferences(
+      objectTypeSchema.Enum.collection,
+      props.projectId
+    )).length;
+    return count;
   }
   /**
-   * Type guard for GitTag
-   *
-   * @param obj The object to check
+   * Checks if given object is of type Collection
    */
-  isGitTag(obj) {
-    return gitTagSchema.safeParse(obj).success;
+  isCollection(obj) {
+    return collectionFileSchema.safeParse(obj).success;
   }
 };
 
-// src/service/UserService.ts
-var UserService = class {
-  constructor(jsonFileService) {
+// src/service/EntryService.ts
+import Fs4 from "fs-extra";
+var EntryService = class extends AbstractCrudService {
+  jsonFileService;
+  gitService;
+  collectionService;
+  assetService;
+  // private sharedValueService: SharedValueService;
+  constructor(options, jsonFileService, gitService, collectionService, assetService) {
+    super(serviceTypeSchema.Enum.Entry, options);
     this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+    this.collectionService = collectionService;
+    this.assetService = assetService;
   }
   /**
-   * Returns the User currently working with Core
+   * Creates a new Entry for given Collection
    */
-  async get() {
-    try {
-      return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
-    } catch (error) {
-      return void 0;
-    }
+  async create(props) {
+    createEntrySchema.parse(props);
+    const id = uuid();
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      id
+    );
+    const collection = await this.collectionService.read({
+      projectId: props.projectId,
+      id: props.collectionId
+    });
+    const entryFile = {
+      objectType: "entry",
+      id,
+      values: props.values,
+      created: datetime(),
+      updated: null
+    };
+    const entry = await this.toEntry({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      entryFile
+    });
+    this.validateValues({
+      collectionId: props.collectionId,
+      valueDefinitions: collection.valueDefinitions,
+      values: entry.values
+    });
+    await this.jsonFileService.create(
+      entryFile,
+      entryFilePath,
+      entryFileSchema
+    );
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return entry;
   }
   /**
-   * Sets the User currently working with Core
-   *
-   * By doing so all git operations are done with the signature of this User
+   * Returns an Entry from given Collection by ID and language
    */
-  async set(props) {
-    setUserSchema.parse(props);
-    const userFilePath = pathTo.userFile;
-    const userFile = {
-      ...props
-    };
-    if (userFile.userType === UserTypeSchema.Enum.cloud) {
-    }
-    await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
-    return userFile;
+  async read(props) {
+    readEntrySchema.parse(props);
+    const entryFile = await this.jsonFileService.read(
+      pathTo.entryFile(props.projectId, props.collectionId, props.id),
+      entryFileSchema
+    );
+    return await this.toEntry({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      entryFile
+    });
   }
-};
-
-// src/service/GitService.ts
-var GitService2 = class {
-  constructor(options, userService) {
-    this.branches = {
-      /**
-       * List branches
-       *
-       * @see https://www.git-scm.com/docs/git-branch
-       *
-       * @param path  Path to the repository
-       */
-      list: async (path) => {
-        const args = ["branch", "--list", "--all"];
-        const result = await this.git(path, args);
-        const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
-          return line.trim() !== "";
-        }).map((line) => {
-          return line.trim().replace("* ", "");
-        });
-        const local = [];
-        const remote = [];
-        normalizedLinesArr.forEach((line) => {
-          if (line.startsWith("remotes/")) {
-            remote.push(line.replace("remotes/", ""));
-          } else {
-            local.push(line);
-          }
-        });
-        return {
-          local,
-          remote
-        };
-      },
-      /**
-       * Returns the name of the current branch. In detached HEAD state, an empty string is returned.
-       *
-       * @see https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current
-       *
-       * @param path  Path to the repository
-       */
-      current: async (path) => {
-        const args = ["branch", "--show-current"];
-        const result = await this.git(path, args);
-        return result.stdout.trim();
-      },
-      /**
-       * Switch branches
-       *
-       * @see https://git-scm.com/docs/git-switch/
-       *
-       * @param path    Path to the repository
-       * @param branch  Name of the branch to switch to
-       * @param options Options specific to the switch operation
-       */
-      switch: async (path, branch, options) => {
-        await this.checkBranchOrTagName(path, branch);
-        let args = ["switch"];
-        if (options?.isNew === true) {
-          args = [...args, "--create", branch];
-        } else {
-          args = [...args, branch];
-        }
-        await this.git(path, args);
-      }
-    };
-    this.remotes = {
-      /**
-       * Returns a list of currently tracked remotes
-       *
-       * @see https://git-scm.com/docs/git-remote
-       *
-       * @param path  Path to the repository
-       */
-      list: async (path) => {
-        const args = ["remote"];
-        const result = await this.git(path, args);
-        const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
-          return line.trim() !== "";
-        });
-        return normalizedLinesArr;
-      },
-      /**
-       * Returns true if the `origin` remote exists, otherwise false
-       *
-       * @param path  Path to the repository
-       */
-      hasOrigin: async (path) => {
-        const remotes = await this.remotes.list(path);
-        if (remotes.includes("origin")) {
-          return true;
-        }
-        return false;
-      },
-      /**
-       * Adds the `origin` remote with given URL
-       *
-       * Throws if `origin` remote is added already.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emaddem
-       *
-       * @param path  Path to the repository
-       */
-      addOrigin: async (path, url) => {
-        const args = ["remote", "add", "origin", url];
-        await this.git(path, args);
-      },
-      /**
-       * Returns the current `origin` remote URL
-       *
-       * Throws if no `origin` remote is added yet.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emget-urlem
-       *
-       * @param path  Path to the repository
-       */
-      getOriginUrl: async (path) => {
-        const args = ["remote", "get-url", "origin"];
-        const result = (await this.git(path, args)).stdout.trim();
-        return result.length === 0 ? null : result;
-      },
-      /**
-       * Sets the current `origin` remote URL
-       *
-       * Throws if no `origin` remote is added yet.
-       *
-       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emset-urlem
-       *
-       * @param path  Path to the repository
-       */
-      setOriginUrl: async (path, url) => {
-        const args = ["remote", "set-url", "origin", url];
-        await this.git(path, args);
-      }
+  /**
+   * Updates an Entry of given Collection with new Values and shared Values
+   */
+  async update(props) {
+    updateEntrySchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      props.id
+    );
+    const collection = await this.collectionService.read({
+      projectId: props.projectId,
+      id: props.collectionId
+    });
+    const prevEntryFile = await this.read({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      id: props.id
+    });
+    const entryFile = {
+      ...prevEntryFile,
+      values: props.values,
+      updated: datetime()
     };
-    this.version = null;
-    this.gitPath = null;
-    this.queue = new PQueue({
-      concurrency: 1
-      // No concurrency because git operations are sequencial
+    const entry = await this.toEntry({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      entryFile
     });
-    this.gitTagService = new GitTagService(options, this.git);
-    this.userService = userService;
-    this.updateVersion();
-    this.updateGitPath();
+    this.validateValues({
+      collectionId: props.collectionId,
+      valueDefinitions: collection.valueDefinitions,
+      values: entry.values
+    });
+    await this.jsonFileService.update(
+      entryFile,
+      entryFilePath,
+      entryFileSchema
+    );
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return entry;
   }
   /**
-   * CRUD methods to work with git tags
+   * Deletes given Entry from it's Collection
    */
-  get tags() {
-    return this.gitTagService;
+  async delete(props) {
+    deleteEntrySchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      props.id
+    );
+    await Fs4.remove(entryFilePath);
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    listEntriesSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const entryReferences = await this.listReferences(
+      objectTypeSchema.Enum.entry,
+      props.projectId,
+      props.collectionId
+    );
+    const partialEntryReferences = entryReferences.slice(offset, limit);
+    const entries = await returnResolved(
+      partialEntryReferences.map((reference) => {
+        return this.read({
+          projectId: props.projectId,
+          collectionId: props.collectionId,
+          id: reference.id
+        });
+      })
+    );
+    return {
+      total: entryReferences.length,
+      limit,
+      offset,
+      list: entries
+    };
+  }
+  async count(props) {
+    countEntriesSchema.parse(props);
+    return (await this.listReferences(
+      objectTypeSchema.Enum.entry,
+      props.projectId,
+      props.collectionId
+    )).length;
   }
   /**
-   * Create an empty Git repository or reinitialize an existing one
-   *
-   * @see https://git-scm.com/docs/git-init
-   *
-   * @param path    Path to initialize in. Fails if path does not exist
-   * @param options Options specific to the init operation
+   * Checks if given object is of type Entry
    */
-  async init(path, options) {
-    let args = ["init"];
-    if (options?.initialBranch) {
-      args = [...args, `--initial-branch=${options.initialBranch}`];
-    }
-    await this.git(path, args);
-    await this.setLocalConfig(path);
-    await this.installLfs(path);
+  isEntry(obj) {
+    return entrySchema.safeParse(obj).success;
   }
   /**
-   * Clone a repository into a directory
-   *
-   * @see https://git-scm.com/docs/git-clone
-   *
-   * @todo Implement progress callback / events
-   *
-   * @param url     The remote repository URL to clone from
-   * @param path    The destination path for the cloned repository.
-   *                Which is only working if the directory is existing and empty.
-   * @param options Options specific to the clone operation
+   * Returns a Value definition by ID
    */
-  async clone(url, path, options) {
-    let args = ["clone", "--progress"];
-    if (options?.branch) {
-      args = [...args, "--branch", options.branch];
+  getValueDefinitionById(props) {
+    const definition = props.valueDefinitions.find((def) => {
+      if (def.id === props.id) {
+        return true;
+      }
+      return false;
+    });
+    if (!definition) {
+      throw new Error(
+        `No definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
+      );
     }
-    if (options?.depth) {
-      args = [...args, "--depth", options.depth.toString()];
+    return definition;
+  }
+  /**
+   * Validates given Values against it's Collections definitions
+   */
+  validateValues(props) {
+    props.values.map((value) => {
+      const definition = this.getValueDefinitionById({
+        collectionId: props.collectionId,
+        valueDefinitions: props.valueDefinitions,
+        id: value.definitionId
+      });
+      const schema = getValueContentSchemaFromDefinition(definition);
+      try {
+        for (const [, content] of Object.entries(value.content)) {
+          schema.parse(content);
+        }
+      } catch (error) {
+        console.log("Definition:", definition);
+        console.log("Value:", value);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Validates given shared Value references against it's Collections definitions
+   */
+  // private validateResolvedSharedValues(props: {
+  //   collectionId: string;
+  //   valueDefinitions: ValueDefinition[];
+  //   resolvedSharedValues: ResolvedSharedValueReference[];
+  // }) {
+  //   props.resolvedSharedValues.map((value) => {
+  //     const definition = this.getValueDefinitionById({
+  //       collectionId: props.collectionId,
+  //       valueDefinitions: props.valueDefinitions,
+  //       id: value.definitionId,
+  //     });
+  //     const schema = getValueSchemaFromDefinition(definition);
+  //     schema.parse(value.resolved.content);
+  //   });
+  // }
+  async resolveValueContentReference(props) {
+    switch (props.valueContentReference.objectType) {
+      case objectTypeSchema.Enum.asset:
+        return await this.assetService.read({
+          projectId: props.projectId,
+          id: props.valueContentReference.id,
+          language: props.valueContentReference.language
+        });
+      case objectTypeSchema.Enum.entry:
+        return await this.read({
+          projectId: props.projectId,
+          collectionId: props.collectionId,
+          id: props.valueContentReference.id
+        });
+      default:
+        throw new Error(
+          // @ts-ignore
+          `Tried to resolve unsupported Value reference "${props.valueContentReference.referenceObjectType}"`
+        );
     }
-    if (options?.singleBranch === true) {
-      args = [...args, "--single-branch"];
+  }
+  async resolveValueContentReferences(props) {
+    let resolvedContent = {};
+    for (const language in props.valueReference.content) {
+      const referencesOfLanguage = props.valueReference.content[language];
+      if (!referencesOfLanguage) {
+        throw new Error(
+          `Trying to access content references by language "${language}" failed`
+        );
+      }
+      const resolvedReferencesOfLanguage = await Promise.all(
+        referencesOfLanguage.map(async (reference) => {
+          return await this.resolveValueContentReference({
+            projectId: props.projectId,
+            collectionId: props.collectionId,
+            valueContentReference: reference
+          });
+        })
+      );
+      resolvedContent = {
+        ...resolvedContent,
+        [language]: resolvedReferencesOfLanguage
+      };
     }
-    await this.git("", [...args, url, path]);
-    await this.setLocalConfig(path);
+    return resolvedContent;
   }
   /**
-   * Add file contents to the index
-   *
-   * @see https://git-scm.com/docs/git-add
-   *
-   * @param path  Path to the repository
-   * @param files Files to add
+   * Creates an Entry from given EntryFile by resolving it's Values
    */
-  async add(path, files2) {
-    const args = ["add", "--", ...files2];
-    await this.git(path, args);
+  async toEntry(props) {
+    return {
+      ...props.entryFile,
+      // @ts-ignore @todo fixme - I have no idea why this happens. The types seem to be compatible to me and they work
+      values: await Promise.all(
+        props.entryFile.values.map(async (value) => {
+          if (value.valueType === ValueTypeSchema.Enum.reference) {
+            const resolvedContentReferences = await this.resolveValueContentReferences({
+              projectId: props.projectId,
+              collectionId: props.collectionId,
+              valueReference: value
+            });
+            return {
+              ...value,
+              content: resolvedContentReferences
+            };
+          }
+          return value;
+        })
+      )
+    };
+  }
+};
+
+// src/service/GitService.ts
+import { GitProcess } from "dugite";
+import { EOL as EOL2 } from "os";
+import PQueue from "p-queue";
+
+// src/service/GitTagService.ts
+import { EOL } from "os";
+var GitTagService = class extends AbstractCrudService {
+  git;
+  constructor(options, git) {
+    super(serviceTypeSchema.Enum.GitTag, options);
+    this.git = git;
   }
   /**
-   * Reset current HEAD to the specified state
-   *
-   * @todo maybe add more options
-   * @see https://git-scm.com/docs/git-reset
+   * Creates a new tag
    *
-   * @param path    Path to the repository
-   * @param mode    Modifies the working tree depending on given mode
-   * @param commit  Resets the current branch head to this commit / tag
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
    */
-  async reset(path, mode, commit) {
-    const args = ["reset", `--${mode}`, commit];
-    await this.git(path, args);
+  async create(props) {
+    createGitTagSchema.parse(props);
+    const id = uuid();
+    let args = ["tag", "--annotate", id];
+    if (props.hash) {
+      args = [...args, props.hash];
+    }
+    args = [...args, "-m", props.message];
+    await this.git(props.path, args);
+    const tag = await this.read({ path: props.path, id });
+    return tag;
   }
   /**
-   * Restore working tree files
-   *
-   * @see https://git-scm.com/docs/git-restore/
-   *
-   * @todo It's probably a good idea to not use restore
-   * for a use case where someone just wants to have a look
-   * and maybe copy something from a deleted file.
-   * We should use `checkout` without `add .` and `commit` for that
+   * Returns a tag by ID
    *
-   * @param path    Path to the repository
-   * @param source  Git commit SHA or tag name to restore to
-   * @param files   Files to restore
+   * Internally uses list() but only returns the tag with matching ID.
    */
-  // public async restore(
-  //   path: string,
-  //   source: string,
-  //   files: string[]
-  // ): Promise<void> {
-  //   const args = ['restore', `--source=${source}`, ...files];
-  //   await this.git(path, args);
-  // }
+  async read(props) {
+    readGitTagSchema.parse(props);
+    const tags = await this.list({ path: props.path });
+    const tag = tags.list.find((tag2) => {
+      return tag2.id === props.id;
+    });
+    if (!tag) {
+      throw new GitError(
+        `Provided tag with UUID "${props.id}" did not match any known tags`
+      );
+    }
+    return tag;
+  }
   /**
-   * Download objects and refs from remote `origin`
-   *
-   * @see https://www.git-scm.com/docs/git-fetch
+   * Updating a git tag is not supported.
+   * Please delete the old and create a new one
    *
-   * @param path Path to the repository
+   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
    */
-  async fetch(path) {
-    const args = ["fetch"];
-    await this.git(path, args);
+  async update() {
+    throw new Error(
+      "Updating a git tag is not supported. Please delete the old and create a new one"
+    );
   }
   /**
-   * Fetch from and integrate (rebase or merge) with a local branch
+   * Deletes a tag
    *
-   * @see https://git-scm.com/docs/git-pull
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
    *
-   * @param path Path to the repository
+   * @param path  Path to the repository
+   * @param id    UUID of the tag to delete
    */
-  async pull(path) {
-    const args = ["pull"];
-    await this.git(path, args);
+  async delete(props) {
+    deleteGitTagSchema.parse(props);
+    const args = ["tag", "--delete", props.id];
+    await this.git(props.path, args);
   }
   /**
-   * Update remote refs along with associated objects to remote `origin`
+   * Gets all local tags or filter them by pattern
    *
-   * @see https://git-scm.com/docs/git-push
+   * They are sorted by authordate of the commit, not when the tag is created.
+   * This ensures tags are sorted correctly in the timeline of their commits.
    *
-   * @param path Path to the repository
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
    */
-  async push(path, options) {
-    let args = ["push", "origin"];
-    if (options?.all === true) {
-      args = [...args, "--all"];
-    }
-    if (options?.force === true) {
-      args = [...args, "--force"];
-    }
+  async list(props) {
+    listGitTagsSchema.parse(props);
+    let args = ["tag", "--list"];
+    args = [
+      ...args,
+      "--sort=-*authordate",
+      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:iso-strict)"
+    ];
+    const result = await this.git(props.path, args);
+    const noEmptyLinesArr = result.stdout.split(EOL).filter((line) => {
+      return line.trim() !== "";
+    });
+    const lineObjArr = noEmptyLinesArr.map((line) => {
+      const lineArray = line.split("|");
+      return {
+        id: lineArray[0],
+        message: lineArray[1],
+        author: {
+          name: lineArray[2],
+          email: lineArray[3]
+        },
+        datetime: datetime(lineArray[4])
+      };
+    });
+    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
+    return {
+      total: gitTags.length,
+      limit: 0,
+      offset: 0,
+      list: gitTags
+    };
+  }
+  /**
+   * Returns the total number of tags inside given repository
+   *
+   * Internally uses list(), so do not use count()
+   * in conjuncion with it to avoid multiple git calls.
+   *
+   * @param path Path to the repository
+   */
+  async count(props) {
+    countGitTagsSchema.parse(props);
+    const gitTags = await this.list({ path: props.path });
+    return gitTags.total;
+  }
+  /**
+   * Type guard for GitTag
+   *
+   * @param obj The object to check
+   */
+  isGitTag(obj) {
+    return gitTagSchema.safeParse(obj).success;
+  }
+};
+
+// src/service/GitService.ts
+var GitService = class {
+  version;
+  gitPath;
+  queue;
+  gitTagService;
+  userService;
+  constructor(options, userService) {
+    this.version = null;
+    this.gitPath = null;
+    this.queue = new PQueue({
+      concurrency: 1
+      // No concurrency because git operations are sequencial
+    });
+    this.gitTagService = new GitTagService(options, this.git);
+    this.userService = userService;
+    this.updateVersion();
+    this.updateGitPath();
+  }
+  /**
+   * CRUD methods to work with git tags
+   */
+  get tags() {
+    return this.gitTagService;
+  }
+  /**
+   * Create an empty Git repository or reinitialize an existing one
+   *
+   * @see https://git-scm.com/docs/git-init
+   *
+   * @param path    Path to initialize in. Fails if path does not exist
+   * @param options Options specific to the init operation
+   */
+  async init(path, options) {
+    let args = ["init"];
+    if (options?.initialBranch) {
+      args = [...args, `--initial-branch=${options.initialBranch}`];
+    }
+    await this.git(path, args);
+    await this.setLocalConfig(path);
+    await this.installLfs(path);
+  }
+  /**
+   * Clone a repository into a directory
+   *
+   * @see https://git-scm.com/docs/git-clone
+   *
+   * @todo Implement progress callback / events
+   *
+   * @param url     The remote repository URL to clone from
+   * @param path    The destination path for the cloned repository.
+   *                Which is only working if the directory is existing and empty.
+   * @param options Options specific to the clone operation
+   */
+  async clone(url, path, options) {
+    let args = ["clone", "--progress"];
+    if (options?.branch) {
+      args = [...args, "--branch", options.branch];
+    }
+    if (options?.depth) {
+      args = [...args, "--depth", options.depth.toString()];
+    }
+    if (options?.singleBranch === true) {
+      args = [...args, "--single-branch"];
+    }
+    await this.git("", [...args, url, path]);
+    await this.setLocalConfig(path);
+  }
+  /**
+   * Add file contents to the index
+   *
+   * @see https://git-scm.com/docs/git-add
+   *
+   * @param path  Path to the repository
+   * @param files Files to add
+   */
+  async add(path, files2) {
+    const args = ["add", "--", ...files2];
+    await this.git(path, args);
+  }
+  branches = {
+    /**
+     * List branches
+     *
+     * @see https://www.git-scm.com/docs/git-branch
+     *
+     * @param path  Path to the repository
+     */
+    list: async (path) => {
+      const args = ["branch", "--list", "--all"];
+      const result = await this.git(path, args);
+      const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
+        return line.trim() !== "";
+      }).map((line) => {
+        return line.trim().replace("* ", "");
+      });
+      const local = [];
+      const remote = [];
+      normalizedLinesArr.forEach((line) => {
+        if (line.startsWith("remotes/")) {
+          remote.push(line.replace("remotes/", ""));
+        } else {
+          local.push(line);
+        }
+      });
+      return {
+        local,
+        remote
+      };
+    },
+    /**
+     * Returns the name of the current branch. In detached HEAD state, an empty string is returned.
+     *
+     * @see https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current
+     *
+     * @param path  Path to the repository
+     */
+    current: async (path) => {
+      const args = ["branch", "--show-current"];
+      const result = await this.git(path, args);
+      return result.stdout.trim();
+    },
+    /**
+     * Switch branches
+     *
+     * @see https://git-scm.com/docs/git-switch/
+     *
+     * @param path    Path to the repository
+     * @param branch  Name of the branch to switch to
+     * @param options Options specific to the switch operation
+     */
+    switch: async (path, branch, options) => {
+      await this.checkBranchOrTagName(path, branch);
+      let args = ["switch"];
+      if (options?.isNew === true) {
+        args = [...args, "--create", branch];
+      } else {
+        args = [...args, branch];
+      }
+      await this.git(path, args);
+    }
+  };
+  remotes = {
+    /**
+     * Returns a list of currently tracked remotes
+     *
+     * @see https://git-scm.com/docs/git-remote
+     *
+     * @param path  Path to the repository
+     */
+    list: async (path) => {
+      const args = ["remote"];
+      const result = await this.git(path, args);
+      const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
+        return line.trim() !== "";
+      });
+      return normalizedLinesArr;
+    },
+    /**
+     * Returns true if the `origin` remote exists, otherwise false
+     *
+     * @param path  Path to the repository
+     */
+    hasOrigin: async (path) => {
+      const remotes = await this.remotes.list(path);
+      if (remotes.includes("origin")) {
+        return true;
+      }
+      return false;
+    },
+    /**
+     * Adds the `origin` remote with given URL
+     *
+     * Throws if `origin` remote is added already.
+     *
+     * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emaddem
+     *
+     * @param path  Path to the repository
+     */
+    addOrigin: async (path, url) => {
+      const args = ["remote", "add", "origin", url];
+      await this.git(path, args);
+    },
+    /**
+     * Returns the current `origin` remote URL
+     *
+     * Throws if no `origin` remote is added yet.
+     *
+     * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emget-urlem
+     *
+     * @param path  Path to the repository
+     */
+    getOriginUrl: async (path) => {
+      const args = ["remote", "get-url", "origin"];
+      const result = (await this.git(path, args)).stdout.trim();
+      return result.length === 0 ? null : result;
+    },
+    /**
+     * Sets the current `origin` remote URL
+     *
+     * Throws if no `origin` remote is added yet.
+     *
+     * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emset-urlem
+     *
+     * @param path  Path to the repository
+     */
+    setOriginUrl: async (path, url) => {
+      const args = ["remote", "set-url", "origin", url];
+      await this.git(path, args);
+    }
+  };
+  /**
+   * Reset current HEAD to the specified state
+   *
+   * @todo maybe add more options
+   * @see https://git-scm.com/docs/git-reset
+   *
+   * @param path    Path to the repository
+   * @param mode    Modifies the working tree depending on given mode
+   * @param commit  Resets the current branch head to this commit / tag
+   */
+  async reset(path, mode, commit) {
+    const args = ["reset", `--${mode}`, commit];
+    await this.git(path, args);
+  }
+  /**
+   * Restore working tree files
+   *
+   * @see https://git-scm.com/docs/git-restore/
+   *
+   * @todo It's probably a good idea to not use restore
+   * for a use case where someone just wants to have a look
+   * and maybe copy something from a deleted file.
+   * We should use `checkout` without `add .` and `commit` for that
+   *
+   * @param path    Path to the repository
+   * @param source  Git commit SHA or tag name to restore to
+   * @param files   Files to restore
+   */
+  // public async restore(
+  //   path: string,
+  //   source: string,
+  //   files: string[]
+  // ): Promise<void> {
+  //   const args = ['restore', `--source=${source}`, ...files];
+  //   await this.git(path, args);
+  // }
+  /**
+   * Download objects and refs from remote `origin`
+   *
+   * @see https://www.git-scm.com/docs/git-fetch
+   *
+   * @param path Path to the repository
+   */
+  async fetch(path) {
+    const args = ["fetch"];
+    await this.git(path, args);
+  }
+  /**
+   * Fetch from and integrate (rebase or merge) with a local branch
+   *
+   * @see https://git-scm.com/docs/git-pull
+   *
+   * @param path Path to the repository
+   */
+  async pull(path) {
+    const args = ["pull"];
+    await this.git(path, args);
+  }
+  /**
+   * Update remote refs along with associated objects to remote `origin`
+   *
+   * @see https://git-scm.com/docs/git-push
+   *
+   * @param path Path to the repository
+   */
+  async push(path, options) {
+    let args = ["push", "origin"];
+    if (options?.all === true) {
+      args = [...args, "--all"];
+    }
+    if (options?.force === true) {
+      args = [...args, "--force"];
+    }
     await this.git(path, args);
   }
   /**
@@ -1996,7 +2335,7 @@ var GitService2 = class {
     }
     const result = await this.git(path, [
       ...args,
-      "--format=%H|%s|%an|%ae|%at|%D"
+      "--format=%H|%s|%an|%ae|%aI|%D"
     ]);
     const noEmptyLinesArr = result.stdout.split(EOL2).filter((line) => {
       return line.trim() !== "";
@@ -2010,8 +2349,8 @@ var GitService2 = class {
           name: lineArray[2],
           email: lineArray[3]
         },
-        timestamp: parseInt(lineArray[4]),
-        tag: this.refNameToTagName(lineArray[5])
+        datetime: datetime(lineArray[4]),
+        tag: this.refNameToTagName(lineArray[5] || "")
       };
     });
     return lineObjArr.filter(this.isGitCommit.bind(this));
@@ -2024,69 +2363,13 @@ var GitService2 = class {
     return tagName;
   }
   /**
-   * Returns a timestamp of given files creation
-   *
-   * Git only returns the timestamp the file was added,
-   * which could be different from the file being created.
-   * But since file operations will always be committed
-   * immediately, this is practically the same.
+   * Reads the currently used version of Git
    *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
+   * This can help debugging
    */
-  async getFileCreatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--diff-filter=A",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns a timestamp of the files last modification
-   *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
-   */
-  async getFileLastUpdatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns created and updated timestamps from given file
-   *
-   * @param path Path to the project
-   * @param file Path to the file
-   */
-  async getFileCreatedUpdatedMeta(path, file) {
-    const meta = await Promise.all([
-      this.getFileCreatedTimestamp(path, file),
-      this.getFileLastUpdatedTimestamp(path, file)
-    ]);
-    return {
-      created: meta[0],
-      updated: meta[1]
-    };
-  }
-  /**
-   * Reads the currently used version of Git
-   *
-   * This can help debugging
-   */
-  async updateVersion() {
-    const result = await this.git("", ["--version"]);
-    this.version = result.stdout.replace("git version", "").trim();
+  async updateVersion() {
+    const result = await this.git("", ["--version"]);
+    this.version = result.stdout.replace("git version", "").trim();
   }
   /**
    * Reads the path to the executable of Git that is used
@@ -2144,475 +2427,118 @@ var GitService2 = class {
     await this.git(path, autoSetupRemoteArgs);
   }
   /**
-   * Type guard for GitCommit
-   *
-   * @param obj The object to check
-   */
-  isGitCommit(obj) {
-    return gitCommitSchema.safeParse(obj).success;
-  }
-  /**
-   * Wraps the execution of any git command
-   * to use a FIFO queue for sequential processing
-   *
-   * @param path Path to the repository
-   * @param args Arguments to append after the `git` command
-   */
-  async git(path, args) {
-    const result = await this.queue.add(
-      () => GitProcess.exec(args, path, {
-        env: {
-          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
-          // @see https://github.com/git-lfs/git-lfs/issues/5749
-          GIT_CLONE_PROTECTION_ACTIVE: "false"
-        }
-      })
-    );
-    if (!result) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed to return a result`
-      );
-    }
-    if (result.exitCode !== 0) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
-      );
-    }
-    return result;
-  }
-};
-
-// src/service/CollectionService.ts
-var CollectionService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Collection, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-  }
-  /**
-   * Creates a new Collection
-   */
-  async create(props) {
-    createCollectionSchema.parse(props);
-    const id = uuid();
-    const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(props.projectId, id);
-    const collectionFilePath = pathTo.collectionFile(props.projectId, id);
-    const collectionFile = {
-      ...props,
-      objectType: "collection",
-      id,
-      slug: {
-        singular: slug(props.slug.singular),
-        plural: slug(props.slug.plural)
-      },
-      created: currentTimestamp(),
-      updated: null
-    };
-    await Fs4.ensureDir(collectionPath);
-    await this.jsonFileService.create(
-      collectionFile,
-      collectionFilePath,
-      collectionFileSchema
-    );
-    await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return collectionFile;
-  }
-  /**
-   * Returns a Collection by ID
-   */
-  async read(props) {
-    readCollectionSchema.parse(props);
-    const collection = await this.jsonFileService.read(
-      pathTo.collectionFile(props.projectId, props.id),
-      collectionFileSchema
-    );
-    return collection;
-  }
-  /**
-   * Updates given Collection
-   *
-   * @todo finish implementing checks for FieldDefinitions and extract methods
-   *
-   * @param projectId   Project ID of the collection to update
-   * @param collection  Collection to write to disk
-   * @returns           An object containing information about the actions needed to be taken,
-   *                    before given update can be executed or void if the update was executed successfully
-   */
-  async update(props) {
-    updateCollectionSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
-    const prevCollectionFile = await this.read(props);
-    const collectionFile = {
-      ...prevCollectionFile,
-      ...props,
-      updated: currentTimestamp()
-    };
-    await this.jsonFileService.update(
-      collectionFile,
-      collectionFilePath,
-      collectionFileSchema
-    );
-    await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return collectionFile;
-  }
-  /**
-   * Deletes given Collection (folder), including it's items
-   *
-   * The Fields that Collection used are not deleted.
-   */
-  async delete(props) {
-    deleteCollectionSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(props.projectId, props.id);
-    await Fs4.remove(collectionPath);
-    await this.gitService.add(projectPath, [collectionPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listCollectionsSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const collectionReferences = await this.listReferences(
-      objectTypeSchema.Enum.collection,
-      props.projectId
-    );
-    const partialCollectionReferences = collectionReferences.slice(
-      offset,
-      limit
-    );
-    const collections = await returnResolved(
-      partialCollectionReferences.map((reference) => {
-        return this.read({
-          projectId: props.projectId,
-          id: reference.id
-        });
-      })
-    );
-    return {
-      total: collectionReferences.length,
-      limit,
-      offset,
-      list: collections
-    };
-  }
-  async count(props) {
-    countCollectionsSchema.parse(props);
-    const count = (await this.listReferences(
-      objectTypeSchema.Enum.collection,
-      props.projectId
-    )).length;
-    return count;
-  }
-  /**
-   * Checks if given object is of type Collection
-   */
-  isCollection(obj) {
-    return collectionFileSchema.safeParse(obj).success;
-  }
-};
-
-// src/service/EntryService.ts
-import Fs5 from "fs-extra";
-var EntryService = class extends AbstractCrudService {
-  // private sharedValueService: SharedValueService;
-  constructor(options, jsonFileService, gitService, collectionService, assetService) {
-    super(serviceTypeSchema.Enum.Entry, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-    this.collectionService = collectionService;
-    this.assetService = assetService;
-  }
-  /**
-   * Creates a new Entry for given Collection
-   */
-  async create(props) {
-    createEntrySchema.parse(props);
-    const id = uuid();
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      id
-    );
-    const collection = await this.collectionService.read({
-      projectId: props.projectId,
-      id: props.collectionId
-    });
-    const entryFile = {
-      objectType: "entry",
-      id,
-      values: props.values,
-      created: currentTimestamp(),
-      updated: null
-    };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-    this.validateValues({
-      collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
-      values: entry.values
-    });
-    await this.jsonFileService.create(
-      entryFile,
-      entryFilePath,
-      entryFileSchema
-    );
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return entry;
-  }
-  /**
-   * Returns an Entry from given Collection by ID and language
-   */
-  async read(props) {
-    readEntrySchema.parse(props);
-    const entryFile = await this.jsonFileService.read(
-      pathTo.entryFile(props.projectId, props.collectionId, props.id),
-      entryFileSchema
-    );
-    return await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-  }
-  /**
-   * Updates an Entry of given Collection with new Values and shared Values
-   */
-  async update(props) {
-    updateEntrySchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      props.id
-    );
-    const collection = await this.collectionService.read({
-      projectId: props.projectId,
-      id: props.collectionId
-    });
-    const prevEntryFile = await this.read({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      id: props.id
-    });
-    const entryFile = {
-      ...prevEntryFile,
-      values: props.values,
-      updated: currentTimestamp()
-    };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
-    this.validateValues({
-      collectionId: props.collectionId,
-      valueDefinitions: collection.valueDefinitions,
-      values: entry.values
-    });
-    await this.jsonFileService.update(
-      entryFile,
-      entryFilePath,
-      entryFileSchema
-    );
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return entry;
-  }
-  /**
-   * Deletes given Entry from it's Collection
-   */
-  async delete(props) {
-    deleteEntrySchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const entryFilePath = pathTo.entryFile(
-      props.projectId,
-      props.collectionId,
-      props.id
-    );
-    await Fs5.remove(entryFilePath);
-    await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listEntriesSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const entryReferences = await this.listReferences(
-      objectTypeSchema.Enum.entry,
-      props.projectId,
-      props.collectionId
-    );
-    const partialEntryReferences = entryReferences.slice(offset, limit);
-    const entries = await returnResolved(
-      partialEntryReferences.map((reference) => {
-        return this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: reference.id
-        });
-      })
-    );
-    return {
-      total: entryReferences.length,
-      limit,
-      offset,
-      list: entries
-    };
-  }
-  async count(props) {
-    countEntriesSchema.parse(props);
-    return (await this.listReferences(
-      objectTypeSchema.Enum.entry,
-      props.projectId,
-      props.collectionId
-    )).length;
-  }
-  /**
-   * Checks if given object is of type Entry
+   * Type guard for GitCommit
+   *
+   * @param obj The object to check
    */
-  isEntry(obj) {
-    return entrySchema.safeParse(obj).success;
+  isGitCommit(obj) {
+    return gitCommitSchema.safeParse(obj).success;
   }
   /**
-   * Returns a Value definition by ID
+   * Wraps the execution of any git command
+   * to use a FIFO queue for sequential processing
+   *
+   * @param path Path to the repository
+   * @param args Arguments to append after the `git` command
    */
-  getValueDefinitionById(props) {
-    const definition = props.valueDefinitions.find((def) => {
-      if (def.id === props.id) {
-        return true;
-      }
-      return false;
-    });
-    if (!definition) {
-      throw new Error(
-        `No definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
+  async git(path, args) {
+    const result = await this.queue.add(
+      () => GitProcess.exec(args, path, {
+        env: {
+          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
+          // @see https://github.com/git-lfs/git-lfs/issues/5749
+          GIT_CLONE_PROTECTION_ACTIVE: "false"
+        }
+      })
+    );
+    if (!result) {
+      throw new GitError(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
+          " "
+        )}" failed to return a result`
       );
     }
-    return definition;
+    if (result.exitCode !== 0) {
+      throw new GitError(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
+          " "
+        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
+      );
+    }
+    return result;
+  }
+};
+
+// src/service/JsonFileService.ts
+import Fs5 from "fs-extra";
+var JsonFileService = class extends AbstractCrudService {
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(serviceTypeSchema.Enum.JsonFile, options);
   }
   /**
-   * Validates given Values against it's Collections definitions
+   * Creates a new file on disk. Fails if path already exists
+   *
+   * @param data Data to write into the file
+   * @param path Path to write the file to
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  validateValues(props) {
-    props.values.map((value) => {
-      const definition = this.getValueDefinitionById({
-        collectionId: props.collectionId,
-        valueDefinitions: props.valueDefinitions,
-        id: value.definitionId
-      });
-      const schema = getValueContentSchemaFromDefinition(definition);
-      try {
-        for (const [language, content] of Object.entries(value.content)) {
-          schema.parse(content);
-        }
-      } catch (error) {
-        console.log("Definition:", definition);
-        console.log("Value:", value);
-        throw error;
-      }
+  async create(data, path, schema) {
+    const parsedData = schema.parse(data);
+    const string = this.serialize(parsedData);
+    await Fs5.writeFile(path, string, {
+      flag: "wx",
+      encoding: "utf8"
     });
+    this.cache.set(path, parsedData);
+    return parsedData;
   }
   /**
-   * Validates given shared Value references against it's Collections definitions
+   * Reads the content of a file on disk. Fails if path does not exist
+   *
+   * @param path Path to read the file from
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  // private validateResolvedSharedValues(props: {
-  //   collectionId: string;
-  //   valueDefinitions: ValueDefinition[];
-  //   resolvedSharedValues: ResolvedSharedValueReference[];
-  // }) {
-  //   props.resolvedSharedValues.map((value) => {
-  //     const definition = this.getValueDefinitionById({
-  //       collectionId: props.collectionId,
-  //       valueDefinitions: props.valueDefinitions,
-  //       id: value.definitionId,
-  //     });
-  //     const schema = getValueSchemaFromDefinition(definition);
-  //     schema.parse(value.resolved.content);
-  //   });
-  // }
-  async resolveValueContentReference(props) {
-    switch (props.valueContentReference.objectType) {
-      case objectTypeSchema.Enum.asset:
-        return await this.assetService.read({
-          projectId: props.projectId,
-          id: props.valueContentReference.id,
-          language: props.valueContentReference.language
-        });
-      case objectTypeSchema.Enum.entry:
-        return await this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: props.valueContentReference.id
-        });
-      default:
-        throw new Error(
-          // @ts-ignore
-          `Tried to resolve unsupported Value reference "${props.valueContentReference.referenceObjectType}"`
-        );
-    }
-  }
-  async resolveValueContentReferences(props) {
-    let resolvedContent = {};
-    for (const language in props.valueReference.content) {
-      const referencesOfLanguage = props.valueReference.content[language];
-      if (!referencesOfLanguage) {
-        throw new Error(
-          `Trying to access content references by language "${language}" failed`
-        );
-      }
-      const resolvedReferencesOfLanguage = await Promise.all(
-        referencesOfLanguage.map(async (reference) => {
-          return await this.resolveValueContentReference({
-            projectId: props.projectId,
-            collectionId: props.collectionId,
-            valueContentReference: reference
-          });
-        })
-      );
-      resolvedContent = {
-        ...resolvedContent,
-        [language]: resolvedReferencesOfLanguage
-      };
+  async read(path, schema) {
+    if (this.cache.has(path)) {
+      return this.cache.get(path);
     }
-    return resolvedContent;
+    const data = await Fs5.readFile(path, {
+      flag: "r",
+      encoding: "utf8"
+    });
+    const json = this.deserialize(data);
+    const parsedData = schema.parse(json);
+    this.cache.set(path, parsedData);
+    return parsedData;
   }
   /**
-   * Creates an Entry from given EntryFile by resolving it's Values
+   * Overwrites an existing file on disk
+   *
+   * @todo Check how to error out if the file does not exist already
+   *
+   * @param data Data to write into the file
+   * @param path Path to the file to overwrite
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  async toEntry(props) {
-    return {
-      ...props.entryFile,
-      // @ts-ignore @todo fixme - I have no idea why this happens. The types seem to be compatible to me and they work
-      values: await Promise.all(
-        props.entryFile.values.map(async (value) => {
-          if (value.valueType === ValueTypeSchema.Enum.reference) {
-            const resolvedContentReferences = await this.resolveValueContentReferences({
-              projectId: props.projectId,
-              collectionId: props.collectionId,
-              valueReference: value
-            });
-            return {
-              ...value,
-              content: resolvedContentReferences
-            };
-          }
-          return value;
-        })
-      )
-    };
+  async update(data, path, schema) {
+    const parsedData = schema.parse(data);
+    const string = this.serialize(parsedData);
+    await Fs5.writeFile(path, string, {
+      flag: "w",
+      encoding: "utf8"
+    });
+    this.cache.set(path, parsedData);
+    return parsedData;
+  }
+  serialize(data) {
+    return JSON.stringify(data, null, this.options.file.json.indentation);
+  }
+  deserialize(data) {
+    return JSON.parse(data);
   }
 };
 
@@ -2622,47 +2548,14 @@ import Os2 from "os";
 import Path2 from "path";
 import Semver from "semver";
 var ProjectService = class extends AbstractCrudService {
+  jsonFileService;
+  userService;
+  gitService;
+  assetService;
+  collectionService;
+  entryService;
   constructor(options, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
     super(serviceTypeSchema.Enum.Project, options);
-    this.branches = {
-      list: async (props) => {
-        listBranchesProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        await this.gitService.fetch(projectPath);
-        return await this.gitService.branches.list(projectPath);
-      },
-      current: async (props) => {
-        currentBranchProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.branches.current(projectPath);
-      },
-      switch: async (props) => {
-        switchBranchProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.branches.switch(
-          projectPath,
-          props.branch,
-          props.options
-        );
-      }
-    };
-    this.remotes = {
-      getOriginUrl: async (props) => {
-        getRemoteOriginUrlProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        return await this.gitService.remotes.getOriginUrl(projectPath);
-      },
-      setOriginUrl: async (props) => {
-        setRemoteOriginUrlProjectSchema.parse(props);
-        const projectPath = pathTo.project(props.id);
-        const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
-        if (!hasOrigin) {
-          await this.gitService.remotes.addOrigin(projectPath, props.url);
-        } else {
-          await this.gitService.remotes.setOriginUrl(projectPath, props.url);
-        }
-      }
-    };
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
@@ -2692,7 +2585,7 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: currentTimestamp(),
+      created: datetime(),
       updated: null,
       coreVersion: this.options.version,
       // @todo should be read from package.json to avoid duplicates
@@ -2776,8 +2669,15 @@ var ProjectService = class extends AbstractCrudService {
     const prevProjectFile = await this.read(props);
     const projectFile = {
       ...prevProjectFile,
-      ...props,
-      updated: currentTimestamp()
+      name: props.name || prevProjectFile.name,
+      description: props.description || prevProjectFile.description,
+      settings: {
+        language: {
+          supported: props.settings?.language.supported || prevProjectFile.settings.language.supported,
+          default: props.settings?.language.default || prevProjectFile.settings.language.default
+        }
+      },
+      updated: datetime()
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
@@ -2822,6 +2722,7 @@ var ProjectService = class extends AbstractCrudService {
       if (upgrade.to !== "0.0.0") {
         return upgrade;
       }
+      return;
     });
     for (let index = 0; index < sortedUpgrades.length; index++) {
       const upgrade = sortedUpgrades[index];
@@ -2852,6 +2753,45 @@ var ProjectService = class extends AbstractCrudService {
       }
     }
   }
+  branches = {
+    list: async (props) => {
+      listBranchesProjectSchema.parse(props);
+      const projectPath = pathTo.project(props.id);
+      await this.gitService.fetch(projectPath);
+      return await this.gitService.branches.list(projectPath);
+    },
+    current: async (props) => {
+      currentBranchProjectSchema.parse(props);
+      const projectPath = pathTo.project(props.id);
+      return await this.gitService.branches.current(projectPath);
+    },
+    switch: async (props) => {
+      switchBranchProjectSchema.parse(props);
+      const projectPath = pathTo.project(props.id);
+      return await this.gitService.branches.switch(
+        projectPath,
+        props.branch,
+        props.options
+      );
+    }
+  };
+  remotes = {
+    getOriginUrl: async (props) => {
+      getRemoteOriginUrlProjectSchema.parse(props);
+      const projectPath = pathTo.project(props.id);
+      return await this.gitService.remotes.getOriginUrl(projectPath);
+    },
+    setOriginUrl: async (props) => {
+      setRemoteOriginUrlProjectSchema.parse(props);
+      const projectPath = pathTo.project(props.id);
+      const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+      if (!hasOrigin) {
+        await this.gitService.remotes.addOrigin(projectPath, props.url);
+      } else {
+        await this.gitService.remotes.setOriginUrl(projectPath, props.url);
+      }
+    }
+  };
   /**
    * Returns the differences of the given Projects current branch
    * between the local and remote `origin` (commits ahead & behind)
@@ -3003,8 +2943,50 @@ var ProjectService = class extends AbstractCrudService {
   }
 };
 
+// src/service/UserService.ts
+var UserService = class {
+  jsonFileService;
+  constructor(jsonFileService) {
+    this.jsonFileService = jsonFileService;
+  }
+  /**
+   * Returns the User currently working with Core
+   */
+  async get() {
+    try {
+      return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
+    } catch (error) {
+      return void 0;
+    }
+  }
+  /**
+   * Sets the User currently working with Core
+   *
+   * By doing so all git operations are done with the signature of this User
+   */
+  async set(props) {
+    setUserSchema.parse(props);
+    const userFilePath = pathTo.userFile;
+    const userFile = {
+      ...props
+    };
+    if (userFile.userType === UserTypeSchema.Enum.cloud) {
+    }
+    await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
+    return userFile;
+  }
+};
+
 // src/index.node.ts
 var ElekIoCore = class {
+  options;
+  userService;
+  gitService;
+  jsonFileService;
+  assetService;
+  projectService;
+  collectionService;
+  entryService;
   // private readonly sharedValueService: SharedValueService;
   constructor(props) {
     const parsedProps = constructorElekIoCoreSchema.parse(props);
@@ -3020,7 +3002,7 @@ var ElekIoCore = class {
     this.options = Object.assign({}, defaults, parsedProps);
     this.jsonFileService = new JsonFileService(this.options);
     this.userService = new UserService(this.jsonFileService);
-    this.gitService = new GitService2(this.options, this.userService);
+    this.gitService = new GitService(this.options, this.userService);
     this.assetService = new AssetService(
       this.options,
       this.jsonFileService,
@@ -3142,8 +3124,8 @@ export {
   createGitTagSchema,
   createProjectSchema,
   currentBranchProjectSchema,
-  currentTimestamp,
   dateValueDefinitionSchema,
+  datetime,
   datetimeValueDefinitionSchema,
   ElekIoCore as default,
   deleteAssetSchema,