@elek-io/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2250 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import {
+  constructorElekIoCoreSchema,
+  environmentSchema
+} from "@elek-io/shared";
+import Fs8 from "fs-extra";
+
+// src/service/AssetService.ts
+import {
+  assetFileSchema,
+  assetSchema,
+  countAssetsSchema,
+  createAssetSchema,
+  currentTimestamp,
+  deleteAssetSchema,
+  fileTypeSchema as fileTypeSchema2,
+  listAssetsSchema,
+  readAssetSchema,
+  serviceTypeSchema as serviceTypeSchema3,
+  supportedExtensionSchema,
+  supportedFileTypeSchema,
+  supportedMimeTypeSchema,
+  updateAssetSchema,
+  uuid as uuid2
+} from "@elek-io/shared";
+import Fs3 from "fs-extra";
+import IsSvg from "is-svg";
+
+// src/error/RequiredParameterMissingError.ts
+var RequiredParameterMissingError = class extends Error {
+  constructor(parameter) {
+    super(`Missing required parameter "${parameter}"`);
+    this.name = "RequiredParameterMissingError";
+  }
+};
+
+// src/util/index.ts
+var util_exports = {};
+__export(util_exports, {
+  assignDefaultIfMissing: () => assignDefaultIfMissing,
+  files: () => files,
+  folders: () => folders,
+  fromPath: () => fromPath,
+  getDuplicates: () => getDuplicates,
+  getRelativePath: () => getRelativePath,
+  isNoError: () => isNoError,
+  notEmpty: () => notEmpty,
+  pathTo: () => pathTo,
+  returnResolved: () => returnResolved,
+  spawnChildProcess: () => spawnChildProcess,
+  workingDirectory: () => workingDirectory
+});
+import { projectFolderSchema, uuidSchema } from "@elek-io/shared";
+import { spawn } from "child_process";
+import Fs from "fs-extra";
+import { filter, flatten, groupBy, uniq } from "lodash-es";
+import Os from "os";
+import Path from "path";
+var workingDirectory = Path.join(Os.homedir(), "elek.io");
+var pathTo = {
+  tmp: Path.join(workingDirectory, "tmp"),
+  userFile: Path.join(workingDirectory, "user.json"),
+  // logs: Path.join(workingDirectory, 'logs'),
+  projects: Path.join(workingDirectory, "projects"),
+  project: (projectId) => {
+    return Path.join(pathTo.projects, projectId);
+  },
+  projectFile: (projectId) => {
+    return Path.join(pathTo.project(projectId), "project.json");
+  },
+  // projectLogs: (projectId: string): string => {
+  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
+  // },
+  // public: (projectId: string): string => {
+  //   return Path.join(pathTo.project(projectId), 'public');
+  // },
+  lfs: (projectId) => {
+    return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
+  },
+  collections: (projectId) => {
+    return Path.join(
+      pathTo.project(projectId),
+      projectFolderSchema.Enum.collections
+    );
+  },
+  collection: (projectId, id) => {
+    return Path.join(pathTo.collections(projectId), id);
+  },
+  collectionFile: (projectId, id) => {
+    return Path.join(pathTo.collection(projectId, id), "collection.json");
+  },
+  entries: (projectId, collectionId) => {
+    return Path.join(pathTo.collection(projectId, collectionId));
+  },
+  entryFile: (projectId, collectionId, id, language) => {
+    return Path.join(
+      pathTo.entries(projectId, collectionId),
+      `${id}.${language}.json`
+    );
+  },
+  values: (projectId) => {
+    return Path.join(pathTo.project(projectId), "values");
+  },
+  valueFile: (projectId, id, language) => {
+    return Path.join(pathTo.values(projectId), `${id}.${language}.json`);
+  },
+  assets: (projectId) => {
+    return Path.join(
+      pathTo.project(projectId),
+      projectFolderSchema.Enum.assets
+    );
+  },
+  assetFile: (projectId, id, language) => {
+    return Path.join(pathTo.assets(projectId), `${id}.${language}.json`);
+  },
+  asset: (projectId, id, language, extension) => {
+    return Path.join(pathTo.lfs(projectId), `${id}.${language}.${extension}`);
+  }
+};
+var fromPath = {
+  projectId: (path) => {
+    const startsWith = "projects/";
+    const endsWith = "/";
+    const start = path.indexOf(startsWith) + startsWith.length;
+    if (start === -1) {
+      return void 0;
+    }
+    const end = path.indexOf(endsWith, start);
+    const result = path.substring(start, end === -1 ? path.length : end);
+    if (result && uuidSchema.safeParse(result).success) {
+      return result;
+    }
+    return void 0;
+  }
+};
+function assignDefaultIfMissing(value, defaultsTo) {
+  return Object.assign(defaultsTo, value);
+}
+function notEmpty(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    if (value.trim() === "") {
+      return false;
+    }
+  }
+  return true;
+}
+function isNoError(item) {
+  return item instanceof Error !== true;
+}
+async function returnResolved(promises) {
+  const toCheck = [];
+  for (let index = 0; index < promises.length; index++) {
+    const promise = promises[index];
+    if (!promise) {
+      throw new Error(`No promise found at index "${index}"`);
+    }
+    toCheck.push(
+      promise.then((result) => {
+        return result;
+      }).catch((error) => {
+        return new Error(error);
+      })
+    );
+  }
+  const checked = await Promise.all(toCheck);
+  return checked.filter(isNoError);
+}
+function spawnChildProcess(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const childProcess = spawn(command, args, options);
+    let log = "";
+    childProcess.stdout.on("data", (data) => {
+      log += data;
+    });
+    childProcess.stderr.on("data", (data) => {
+      log += data;
+    });
+    childProcess.on("error", (error) => {
+      throw error;
+    });
+    childProcess.on("exit", (code) => {
+      if (code === 0) {
+        return resolve(log);
+      }
+      return reject(log);
+    });
+  });
+}
+async function folders(path) {
+  const dirent = await Fs.readdir(path, { withFileTypes: true });
+  return dirent.filter((dirent2) => {
+    return dirent2.isDirectory();
+  });
+}
+async function files(path, extension) {
+  const dirent = await Fs.readdir(path, { withFileTypes: true });
+  return dirent.filter((dirent2) => {
+    if (extension && dirent2.isFile() === true) {
+      if (dirent2.name.endsWith(extension)) {
+        return true;
+      }
+      return false;
+    }
+    return dirent2.isFile();
+  });
+}
+function getRelativePath(path) {
+  let relativePath = path.replace(workingDirectory, "");
+  if (relativePath.startsWith("/")) {
+    relativePath = relativePath.substr(1);
+  }
+  return relativePath;
+}
+function getDuplicates(arr, key) {
+  const grouped = groupBy(arr, (item) => {
+    return item[key];
+  });
+  return uniq(
+    flatten(
+      filter(grouped, (item) => {
+        return item.length > 1;
+      })
+    )
+  );
+}
+
+// src/service/AbstractCrudService.ts
+import {
+  fileReferenceSchema,
+  fileTypeSchema,
+  gitCommitIconSchema
+} from "@elek-io/shared";
+import { orderBy, remove } from "lodash-es";
+var AbstractCrudService = class {
+  /**
+   * Do not instantiate directly as this is an abstract class
+   */
+  constructor(type, options) {
+    this.type = type;
+    this.options = options;
+    this.gitMessage = {
+      create: `${gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
+      update: `${gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
+      delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
+    };
+  }
+  /**
+   * Returns the filtered, sorted and paginated version of given list
+   *
+   * @todo Sorting and filtering requires all models to be loaded
+   * from disk. This results in a huge memory spike before the
+   * filtering and pagination takes effect - removing most of it again.
+   * This approach is still better than returning everything and
+   * letting the frontend handle it, since the memory usage would then be constant.
+   * But this still could fill the memory limit of node.js (default 1,4 GB).
+   *
+   * @param list Array to filter, sort and paginate
+   * @param sort Array of sort objects containing information about what to sort and how
+   * @param filter Filter all object values of `list` by this string
+   * @param limit Limit the result to this amount. If 0 is given, no limit is applied
+   * @param offset Start at this index instead of 0
+   */
+  async paginate(list, sort = [], filter2 = "", limit = 15, offset = 0) {
+    let result = list;
+    const total = list.length;
+    const normalizedFilter = filter2.trim().toLowerCase();
+    if (normalizedFilter !== "") {
+      remove(result, (model) => {
+        let key;
+        for (key in model) {
+          const value = model[key];
+          if (String(value).toLowerCase().includes(normalizedFilter)) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (sort.length !== 0) {
+      const keys = sort.map((value) => value.by);
+      const orders = sort.map((value) => value.order);
+      result = orderBy(result, keys, orders);
+    }
+    if (limit !== 0) {
+      result = result.slice(offset, offset + limit);
+    }
+    return {
+      total,
+      limit,
+      offset,
+      list: result
+    };
+  }
+  /**
+   * Returns a list of all file references of given project and type
+   *
+   * @param type File type of the references wanted
+   * @param projectId Project to get all asset references from
+   * @param collectionId Only needed when requesting files of type "Entry"
+   */
+  async listReferences(type, projectId, collectionId) {
+    switch (type) {
+      case fileTypeSchema.Enum.asset:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        return this.getFileReferences(pathTo.lfs(projectId));
+      case fileTypeSchema.Enum.project:
+        return this.getFolderReferences(pathTo.projects);
+      case fileTypeSchema.Enum.collection:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        return this.getFolderReferences(pathTo.collections(projectId));
+      case fileTypeSchema.Enum.entry:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        if (!collectionId) {
+          throw new RequiredParameterMissingError("collectionId");
+        }
+        return this.getFileReferences(
+          pathTo.collection(projectId, collectionId)
+        );
+      case fileTypeSchema.Enum.value:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        return this.getFileReferences(pathTo.values(projectId));
+      default:
+        throw new Error(`Trying to list files of unsupported type "${type}"`);
+    }
+  }
+  async getFolderReferences(path) {
+    const possibleFolders = await folders(path);
+    const results = possibleFolders.map((possibleFolder) => {
+      const folderReference = {
+        id: possibleFolder.name
+      };
+      try {
+        return fileReferenceSchema.parse(folderReference);
+      } catch (error) {
+        return null;
+      }
+    });
+    return results.filter(notEmpty);
+  }
+  /**
+   * Searches for all files inside given folder,
+   * parses their names and returns them as FileReference
+   *
+   * Ignores files not matching the [id].[language].[extension]
+   * or [id].[extension] format for their names
+   */
+  async getFileReferences(path) {
+    const possibleFiles = await files(path);
+    const results = await Promise.all(
+      possibleFiles.map(async (possibleFile) => {
+        const fileNameArray = possibleFile.name.split(".");
+        const fileReference = {
+          id: fileNameArray[0],
+          language: fileNameArray.length === 3 ? fileNameArray[1] : void 0,
+          extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
+        };
+        try {
+          return fileReferenceSchema.parse(fileReference);
+        } catch (error) {
+          return null;
+        }
+      })
+    );
+    return results.filter(notEmpty);
+  }
+};
+
+// src/service/GitService.ts
+import {
+  gitCommitSchema,
+  uuidSchema as uuidSchema2
+} from "@elek-io/shared";
+import { GitProcess } from "dugite";
+import PQueue from "p-queue";
+
+// src/error/GitError.ts
+var GitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitError";
+  }
+};
+
+// src/error/NoCurrentUserError.ts
+var NoCurrentUserError = class extends Error {
+  constructor() {
+    super("Make sure to set a User via Core before using other methods");
+    this.name = "NoCurrentUserError";
+  }
+};
+
+// src/service/GitTagService.ts
+import {
+  countGitTagsSchema,
+  createGitTagSchema,
+  deleteGitTagSchema,
+  gitTagSchema,
+  listGitTagsSchema,
+  readGitTagSchema,
+  serviceTypeSchema,
+  uuid
+} from "@elek-io/shared";
+var GitTagService = class extends AbstractCrudService {
+  constructor(options, git) {
+    super(serviceTypeSchema.Enum.GitTag, options);
+    this.git = git;
+  }
+  /**
+   * Creates a new tag
+   *
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
+   */
+  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;
+  }
+  /**
+   * Returns a tag by ID
+   *
+   * Internally uses list() with id as pattern.
+   */
+  async read(props) {
+    readGitTagSchema.parse(props);
+    const tags = await this.list({ path: props.path, filter: props.id });
+    if (tags.total === 0) {
+      throw new GitError(
+        `Provided tag with UUID "${props.id}" did not match any known tags`
+      );
+    }
+    if (tags.total > 1) {
+      throw new GitError(
+        `Provided tag with UUID "${props.id}" matched multiple known tags`
+      );
+    }
+    return tags.list[0];
+  }
+  /**
+   * Updating a git tag is not supported.
+   * Please delete the old and create a new one
+   *
+   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
+   */
+  async update() {
+    throw new Error(
+      "Updating a git tag is not supported. Please delete the old and create a new one"
+    );
+  }
+  /**
+   * Deletes a tag
+   *
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+   *
+   * @param path  Path to the repository
+   * @param id    UUID of the tag to delete
+   */
+  async delete(props) {
+    deleteGitTagSchema.parse(props);
+    const args = ["tag", "--delete", props.id];
+    await this.git(props.path, args);
+  }
+  /**
+   * 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("\n").filter((line) => {
+      return line !== "";
+    });
+    const lineObjArr = noEmptyLinesArr.map((line) => {
+      const lineArray = line.split("|");
+      return {
+        id: lineArray[0],
+        message: lineArray[1],
+        author: {
+          name: lineArray[2],
+          email: lineArray[3]
+        },
+        timestamp: typeof lineArray[4] === "string" ? parseInt(lineArray[4]) : void 0
+      };
+    });
+    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
+    return this.paginate(
+      gitTags,
+      props?.sort,
+      props?.filter,
+      props?.limit,
+      props?.offset
+    );
+  }
+  /**
+   * 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/UserService.ts
+import {
+  UserTypeSchema,
+  setUserSchema,
+  userFileSchema
+} from "@elek-io/shared";
+
+// src/service/JsonFileService.ts
+import {
+  serviceTypeSchema as serviceTypeSchema2
+} from "@elek-io/shared";
+import Fs2 from "fs-extra";
+var JsonFileService = class extends AbstractCrudService {
+  constructor(options) {
+    super(serviceTypeSchema2.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/UserService.ts
+var UserService = class {
+  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/service/GitService.ts
+var GitService2 = class {
+  constructor(options, userService) {
+    this.version = void 0;
+    this.queue = new PQueue({
+      concurrency: 1
+      // No concurrency because git operations are sequencial
+    });
+    this.gitTagService = new GitTagService(options, this.git);
+    this.userService = userService;
+  }
+  /**
+   * CRUD methods to work with git tags
+   */
+  get tags() {
+    return this.gitTagService;
+  }
+  /**
+   * Reads the currently used version of Git
+   */
+  async getVersion() {
+    const result = await this.git("", ["--version"]);
+    this.version = result.stdout.replace("git version", "").trim();
+  }
+  /**
+   * 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(path, [...args, url, "."]);
+    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);
+  }
+  /**
+   * Switch branches
+   *
+   * @see https://git-scm.com/docs/git-switch/
+   *
+   * @param path    Path to the repository
+   * @param name    Name of the branch to switch to
+   * @param options Options specific to the switch operation
+   */
+  async switch(path, name, options) {
+    await this.checkBranchOrTagName(path, name);
+    let args = ["switch"];
+    if (options?.isNew === true) {
+      args = [...args, "--create", name];
+    } else {
+      args = [...args, name];
+    }
+    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);
+  // }
+  /**
+   * Fetch from and integrate with another repository or 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);
+  }
+  /**
+   * Record changes to the repository
+   *
+   * @see https://git-scm.com/docs/git-commit
+   *
+   * @param path    Path to the repository
+   * @param message A message that describes the changes
+   */
+  async commit(path, message) {
+    const user = await this.userService.get();
+    if (!user) {
+      throw new NoCurrentUserError();
+    }
+    const args = [
+      "commit",
+      `--message=${message}`,
+      `--author=${user.name} <${user.email}>`
+    ];
+    await this.git(path, args);
+  }
+  /**
+   * Gets local commit history
+   *
+   * @see https://git-scm.com/docs/git-log
+   *
+   * @todo Check if there is a need to trim the git commit message of chars
+   * @todo Use this method in a service. Decide if we need a HistoryService for example
+   *
+   * @param path    Path to the repository
+   * @param options Options specific to the log operation
+   */
+  async log(path, options) {
+    let args = ["log"];
+    if (options?.between?.from) {
+      args = [
+        ...args,
+        `${options.between.from}...${options.between.to || "HEAD"}`
+      ];
+    }
+    if (options?.limit) {
+      args = [...args, `--max-count=${options.limit}`];
+    }
+    const result = await this.git(path, [
+      ...args,
+      "--format=%H|%s|%an|%ae|%at|%D"
+    ]);
+    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
+      return line !== "";
+    });
+    const lineObjArr = noEmptyLinesArr.map((line) => {
+      const lineArray = line.split("|");
+      return {
+        hash: lineArray[0],
+        message: lineArray[1],
+        author: {
+          name: lineArray[2],
+          email: lineArray[3]
+        },
+        timestamp: parseInt(lineArray[4]),
+        tag: this.refNameToTagName(lineArray[5])
+      };
+    });
+    return lineObjArr.filter(this.isGitCommit.bind(this));
+  }
+  refNameToTagName(refName) {
+    let tagName = "";
+    tagName = refName.replace("tag: ", "");
+    if (tagName.trim() === "" || uuidSchema2.safeParse(tagName).success === false) {
+      tagName = void 0;
+    }
+    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.
+   *
+   * @param path Path to the repository
+   * @param file File to get timestamp from
+   */
+  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]
+    };
+  }
+  /**
+   * A reference is used in Git to specify branches and tags.
+   * This method checks if given name matches the required format
+   *
+   * @see https://git-scm.com/docs/git-check-ref-format
+   *
+   * @param path Path to the repository
+   * @param name Name to check
+   */
+  async checkBranchOrTagName(path, name) {
+    await this.git(path, ["check-ref-format", "--allow-onelevel", name]);
+  }
+  /**
+   * Installs LFS support and starts tracking
+   * all files inside the lfs folder
+   *
+   * @param path Path to the repository
+   */
+  async installLfs(path) {
+    await this.git(path, ["lfs", "install"]);
+    await this.git(path, ["lfs", "track", "lfs/*"]);
+  }
+  /**
+   * Sets the git config of given local repository from ElekIoCoreOptions
+   *
+   * @param path Path to the repository
+   */
+  async setLocalConfig(path) {
+    const user = await this.userService.get();
+    if (!user) {
+      throw new NoCurrentUserError();
+    }
+    const userNameArgs = ["config", "--local", "user.name", user.name];
+    const userEmailArgs = ["config", "--local", "user.email", user.email];
+    await this.git(path, userNameArgs);
+    await this.git(path, userEmailArgs);
+  }
+  /**
+   * 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));
+    if (!result) {
+      throw new GitError(
+        `Git (${this.version}) command "git ${args.join(
+          " "
+        )}" failed to return a result`
+      );
+    }
+    return result;
+  }
+};
+
+// src/service/AssetService.ts
+var AssetService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService) {
+    super(serviceTypeSchema3.Enum.Asset, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Asset
+   */
+  async create(props) {
+    createAssetSchema.parse(props);
+    const id = uuid2();
+    const projectPath = pathTo.project(props.projectId);
+    const fileType = await this.getSupportedFileTypeOrThrow(props.filePath);
+    const size = await this.getAssetSize(props.filePath);
+    const assetPath = pathTo.asset(
+      props.projectId,
+      id,
+      props.language,
+      fileType.extension
+    );
+    const assetFilePath = pathTo.assetFile(
+      props.projectId,
+      id,
+      props.language
+    );
+    const assetFile = {
+      ...props,
+      fileType: "asset",
+      id,
+      created: currentTimestamp(),
+      extension: fileType.extension,
+      mimeType: fileType.mimeType,
+      size
+    };
+    try {
+      await Fs3.copyFile(props.filePath, assetPath);
+      await this.jsonFileService.create(
+        assetFile,
+        assetFilePath,
+        assetFileSchema
+      );
+    } catch (error) {
+      await this.delete({ ...assetFile, projectId: props.projectId });
+      throw error;
+    }
+    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Returns an Asset by ID and language
+   */
+  async read(props) {
+    readAssetSchema.parse(props);
+    const assetFile = await this.jsonFileService.read(
+      pathTo.assetFile(props.projectId, props.id, props.language),
+      assetFileSchema
+    );
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Updates given Asset
+   *
+   * Use the optional "newFilePath" prop to update the Asset itself
+   */
+  async update(props) {
+    updateAssetSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const assetFilePath = pathTo.assetFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    const prevAssetFile = await this.read(props);
+    const assetFile = {
+      ...prevAssetFile,
+      ...props,
+      updated: currentTimestamp()
+    };
+    if (props.newFilePath) {
+      const fileType = await this.getSupportedFileTypeOrThrow(
+        props.newFilePath
+      );
+      const size = await this.getAssetSize(props.newFilePath);
+      const prevAssetPath = pathTo.asset(
+        props.projectId,
+        props.id,
+        props.language,
+        prevAssetFile.extension
+      );
+      const assetPath = pathTo.asset(
+        props.projectId,
+        props.id,
+        props.language,
+        fileType.extension
+      );
+      await Fs3.remove(prevAssetPath);
+      await Fs3.copyFile(props.newFilePath, assetPath);
+      assetFile.extension = fileType.extension;
+      assetFile.mimeType = fileType.mimeType;
+      assetFile.size = size;
+    }
+    await this.jsonFileService.update(
+      assetFile,
+      assetFilePath,
+      assetFileSchema
+    );
+    await this.gitService.add(projectPath, [assetFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Deletes given Asset
+   */
+  async delete(props) {
+    deleteAssetSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const assetFilePath = pathTo.assetFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    const assetPath = pathTo.asset(
+      props.projectId,
+      props.id,
+      props.language,
+      props.extension
+    );
+    await Fs3.remove(assetPath);
+    await Fs3.remove(assetFilePath);
+    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    listAssetsSchema.parse(props);
+    const assetReferences = await this.listReferences(
+      fileTypeSchema2.Enum.asset,
+      props.projectId
+    );
+    const list = await returnResolved(
+      assetReferences.map((assetReference) => {
+        if (!assetReference.language) {
+          throw new RequiredParameterMissingError("language");
+        }
+        return this.read({
+          projectId: props.projectId,
+          id: assetReference.id,
+          language: assetReference.language
+        });
+      })
+    );
+    const paginatedResult = this.paginate(
+      list,
+      props.sort,
+      props.filter,
+      props.limit,
+      props.offset
+    );
+    return paginatedResult;
+  }
+  async count(props) {
+    countAssetsSchema.parse(props);
+    const count = (await this.listReferences(fileTypeSchema2.Enum.asset, props.projectId)).length;
+    return count;
+  }
+  /**
+   * Checks if given object is of type Asset
+   */
+  isAsset(obj) {
+    return assetSchema.safeParse(obj).success;
+  }
+  /**
+   * Returns the size of an Asset in bytes
+   *
+   * @param path Path of the Asset to get the size from
+   */
+  async getAssetSize(path) {
+    return (await Fs3.stat(path)).size;
+  }
+  /**
+   * Creates an Asset from given AssetFile
+   *
+   * @param projectId   The project's ID
+   * @param assetFile   The AssetFile to convert
+   */
+  async toAsset(projectId, assetFile) {
+    const assetPath = pathTo.asset(
+      projectId,
+      assetFile.id,
+      assetFile.language,
+      assetFile.extension
+    );
+    const asset = {
+      ...assetFile,
+      absolutePath: assetPath
+    };
+    return asset;
+  }
+  /**
+   * Returns the found and supported extension as well as mime type,
+   * otherwise throws an error
+   *
+   * @param filePath Path to the file to check
+   */
+  async getSupportedFileTypeOrThrow(filePath) {
+    const fileSize = (await Fs3.stat(filePath)).size;
+    if (fileSize / 1e3 <= 500) {
+      const fileBuffer = await Fs3.readFile(filePath);
+      if (IsSvg(fileBuffer.toString()) === true) {
+        return {
+          extension: supportedExtensionSchema.Enum.svg,
+          mimeType: supportedMimeTypeSchema.Enum["image/svg+xml"]
+        };
+      }
+    }
+    const { fileTypeFromFile } = await import("file-type");
+    const fileType = await fileTypeFromFile(filePath);
+    const result = supportedFileTypeSchema.parse({
+      extension: fileType?.ext,
+      mimeType: fileType?.mime
+    });
+    return result;
+  }
+};
+
+// src/service/CollectionService.ts
+import {
+  collectionFileSchema,
+  countCollectionsSchema,
+  createCollectionSchema,
+  currentTimestamp as currentTimestamp2,
+  deleteCollectionSchema,
+  fileTypeSchema as fileTypeSchema3,
+  listCollectionsSchema,
+  readCollectionSchema,
+  serviceTypeSchema as serviceTypeSchema4,
+  slug,
+  updateCollectionSchema,
+  uuid as uuid3
+} from "@elek-io/shared";
+import Fs4 from "fs-extra";
+var CollectionService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService) {
+    super(serviceTypeSchema4.Enum.Collection, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Collection
+   */
+  async create(props) {
+    createCollectionSchema.parse(props);
+    const id = uuid3();
+    const projectPath = pathTo.project(props.projectId);
+    const collectionPath = pathTo.collection(props.projectId, id);
+    const collectionFilePath = pathTo.collectionFile(
+      props.projectId,
+      id
+    );
+    const collectionFile = {
+      ...props,
+      fileType: "collection",
+      id,
+      slug: {
+        singular: slug(props.slug.singular),
+        plural: slug(props.slug.plural)
+      },
+      created: currentTimestamp2()
+    };
+    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: currentTimestamp2()
+    };
+    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 references = await this.listReferences(
+      fileTypeSchema3.Enum.collection,
+      props.projectId
+    );
+    const list = await returnResolved(
+      references.map((reference) => {
+        return this.read({
+          projectId: props.projectId,
+          id: reference.id
+        });
+      })
+    );
+    return this.paginate(
+      list,
+      props.sort,
+      props.filter,
+      props.limit,
+      props.offset
+    );
+  }
+  async count(props) {
+    countCollectionsSchema.parse(props);
+    const count = (await this.listReferences(fileTypeSchema3.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 {
+  countEntriesSchema,
+  createEntrySchema,
+  currentTimestamp as currentTimestamp4,
+  deleteEntrySchema,
+  entryFileSchema,
+  entrySchema,
+  fileTypeSchema as fileTypeSchema5,
+  getValueSchemaFromDefinition as getValueSchemaFromDefinition2,
+  listEntriesSchema,
+  readEntrySchema,
+  serviceTypeSchema as serviceTypeSchema6,
+  updateEntrySchema,
+  uuid as uuid5
+} from "@elek-io/shared";
+import Fs6 from "fs-extra";
+
+// src/service/ValueService.ts
+import {
+  countValuesSchema,
+  createValueSchema,
+  currentTimestamp as currentTimestamp3,
+  deleteValueSchema,
+  fileTypeSchema as fileTypeSchema4,
+  getValueSchemaFromDefinition,
+  listValuesSchema,
+  readValueSchema,
+  serviceTypeSchema as serviceTypeSchema5,
+  updateValueSchema,
+  uuid as uuid4,
+  validateValueSchema,
+  valueFileSchema
+} from "@elek-io/shared";
+import Fs5 from "fs-extra";
+var ValueService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService, assetService) {
+    super(serviceTypeSchema5.Enum.Value, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Value
+   */
+  async create(props) {
+    createValueSchema.parse(props);
+    const id = uuid4();
+    const projectPath = pathTo.project(props.projectId);
+    const valueFilePath = pathTo.valueFile(
+      props.projectId,
+      id,
+      props.language
+    );
+    const valueFile = {
+      ...props,
+      fileType: "value",
+      id,
+      created: currentTimestamp3()
+    };
+    await this.jsonFileService.create(
+      valueFile,
+      valueFilePath,
+      valueFileSchema
+    );
+    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return valueFile;
+  }
+  /**
+   * Returns a Value by ID and language
+   */
+  async read(props) {
+    readValueSchema.parse(props);
+    const valueFile = await this.jsonFileService.read(
+      pathTo.valueFile(props.projectId, props.id, props.language),
+      valueFileSchema
+    );
+    return valueFile;
+  }
+  /**
+   * Updates given Value
+   */
+  async update(props) {
+    updateValueSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const valueFilePath = pathTo.valueFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    const prevValueFile = await this.read(props);
+    const valueFile = {
+      ...prevValueFile,
+      ...props,
+      updated: currentTimestamp3()
+    };
+    await this.jsonFileService.update(
+      valueFile,
+      valueFilePath,
+      valueFileSchema
+    );
+    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return valueFile;
+  }
+  /**
+   * Deletes given Value
+   */
+  async delete(props) {
+    deleteValueSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const valueFilePath = pathTo.valueFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    await Fs5.remove(valueFilePath);
+    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    listValuesSchema.parse(props);
+    const references = await this.listReferences(
+      fileTypeSchema4.Enum.value,
+      props.projectId
+    );
+    const list = await returnResolved(
+      references.map((reference) => {
+        if (!reference.language) {
+          throw new RequiredParameterMissingError("language");
+        }
+        return this.read({
+          projectId: props.projectId,
+          id: reference.id,
+          language: reference.language
+        });
+      })
+    );
+    return this.paginate(
+      list,
+      props.sort,
+      props.filter,
+      props.limit,
+      props.offset
+    );
+  }
+  async count(props) {
+    countValuesSchema.parse(props);
+    const count = (await this.listReferences(fileTypeSchema4.Enum.value, props.projectId)).length;
+    return count;
+  }
+  /**
+   * Checks if given object is of type Value
+   */
+  isValue(obj) {
+    return valueFileSchema.safeParse(obj).success;
+  }
+  /**
+   * Reads the given Value from disk and validates it against the ValueDefinition
+   */
+  async validate(props) {
+    validateValueSchema.parse(props);
+    const value = await this.read(props);
+    const valueSchema = getValueSchemaFromDefinition(props.definition);
+    return valueSchema.safeParse(value.content);
+  }
+};
+
+// src/service/EntryService.ts
+var EntryService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService, collectionService, valueService) {
+    super(serviceTypeSchema6.Enum.Entry, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+    this.collectionService = collectionService;
+    this.valueService = valueService;
+  }
+  /**
+   * Creates a new Entry
+   */
+  async create(props) {
+    createEntrySchema.parse(props);
+    const id = uuid5();
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      id,
+      props.language
+    );
+    const collection = await this.collectionService.read({
+      projectId: props.projectId,
+      id: props.collectionId
+    });
+    await this.validateValueReferences(
+      props.projectId,
+      props.collectionId,
+      props.valueReferences,
+      collection.valueDefinitions
+    );
+    const entryFile = {
+      fileType: "entry",
+      id,
+      language: props.language,
+      valueReferences: props.valueReferences,
+      created: currentTimestamp4()
+    };
+    await this.jsonFileService.create(
+      entryFile,
+      entryFilePath,
+      entryFileSchema
+    );
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return entryFile;
+  }
+  /**
+   * Returns an Entry by ID and language
+   */
+  async read(props) {
+    readEntrySchema.parse(props);
+    const entryFile = await this.jsonFileService.read(
+      pathTo.entryFile(
+        props.projectId,
+        props.collectionId,
+        props.id,
+        props.language
+      ),
+      entryFileSchema
+    );
+    return entryFile;
+  }
+  /**
+   * Updates Entry with given ValueReferences
+   */
+  async update(props) {
+    updateEntrySchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      props.id,
+      props.language
+    );
+    const collection = await this.collectionService.read({
+      projectId: props.projectId,
+      id: props.collectionId
+    });
+    await this.validateValueReferences(
+      props.projectId,
+      props.collectionId,
+      props.valueReferences,
+      collection.valueDefinitions
+    );
+    const prevEntryFile = await this.read({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      id: props.id,
+      language: props.language
+    });
+    const entryFile = {
+      ...prevEntryFile,
+      valueReferences: props.valueReferences,
+      updated: currentTimestamp4()
+    };
+    await this.jsonFileService.update(
+      entryFile,
+      entryFilePath,
+      entryFileSchema
+    );
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return entryFile;
+  }
+  /**
+   * Deletes given Entry
+   */
+  async delete(props) {
+    deleteEntrySchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      props.id,
+      props.language
+    );
+    await Fs6.remove(entryFilePath);
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    listEntriesSchema.parse(props);
+    const references = await this.listReferences(
+      fileTypeSchema5.Enum.entry,
+      props.projectId,
+      props.collectionId
+    );
+    const list = await returnResolved(
+      references.map((reference) => {
+        if (!reference.language) {
+          throw new RequiredParameterMissingError("language");
+        }
+        return this.read({
+          projectId: props.projectId,
+          collectionId: props.collectionId,
+          id: reference.id,
+          language: reference.language
+        });
+      })
+    );
+    return this.paginate(
+      list,
+      props.sort,
+      props.filter,
+      props.limit,
+      props.offset
+    );
+  }
+  async count(props) {
+    countEntriesSchema.parse(props);
+    return (await this.listReferences(
+      fileTypeSchema5.Enum.entry,
+      props.projectId,
+      props.collectionId
+    )).length;
+  }
+  /**
+   * Checks if given object of Collection, CollectionItem,
+   * Field, Project or Asset is of type CollectionItem
+   */
+  isEntry(obj) {
+    return entrySchema.safeParse(obj).success;
+  }
+  /**
+   * Validates referenced Values against the Collections definition
+   *
+   * @todo should probably return all errors occurring during parsing instead of throwing
+   */
+  async validateValueReferences(projectId, collectionId, valueReferences, valueDefinitions) {
+    await Promise.all(
+      valueReferences.map(async (reference) => {
+        const definition = valueDefinitions.find((def) => {
+          if (def.id === reference.definitionId) {
+            return true;
+          }
+          return false;
+        });
+        if (!definition) {
+          throw new Error(
+            `No definition with ID "${reference.definitionId}" found in Collection "${collectionId}" for given Value reference`
+          );
+        }
+        const schema = getValueSchemaFromDefinition2(definition);
+        const value = await this.valueService.read({
+          ...reference.references,
+          projectId
+        });
+        schema.parse(value.content);
+      })
+    );
+  }
+};
+
+// src/service/ProjectService.ts
+import {
+  createProjectSchema,
+  currentTimestamp as currentTimestamp5,
+  deleteProjectSchema,
+  fileTypeSchema as fileTypeSchema6,
+  gitCommitIconSchema as gitCommitIconSchema2,
+  listProjectsSchema,
+  projectFileSchema,
+  projectFolderSchema as projectFolderSchema2,
+  readProjectSchema,
+  serviceTypeSchema as serviceTypeSchema8,
+  updateProjectSchema,
+  upgradeProjectSchema,
+  uuid as uuid6
+} from "@elek-io/shared";
+import Fs7 from "fs-extra";
+import Os2 from "os";
+import Path2 from "path";
+import Semver from "semver";
+
+// src/error/ProjectUpgradeError.ts
+var ProjectUpgradeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectUpgradeError";
+  }
+};
+
+// src/service/SearchService.ts
+import {
+  serviceTypeSchema as serviceTypeSchema7
+} from "@elek-io/shared";
+var SearchService = class extends AbstractCrudService {
+  constructor(options, assetService, collectionService) {
+    super(serviceTypeSchema7.enum.Search, options);
+    this.assetService = assetService;
+    this.collectionService = collectionService;
+  }
+  /**
+   * Search all models inside the project for given query
+   *
+   * @todo Implement SearchOptions parameter
+   *
+   * @param project Project to search in
+   * @param query Query to search for
+   */
+  async search(projectId, query, fileType) {
+    const results = [];
+    const normalizedQuery = query.trim();
+    if (normalizedQuery === "") {
+      return results;
+    }
+    const paginatedLists = (await Promise.all([this.assetService.list({ projectId, filter: query })])).flat();
+    paginatedLists.forEach((paginatedList) => {
+      paginatedList.list.flat().forEach((file) => {
+        const result = {
+          id: file.id,
+          language: file.language,
+          name: file.name,
+          type: file.fileType,
+          matches: []
+        };
+        for (const [key, value] of Object.entries(file)) {
+          const valueString = String(value);
+          if (valueString.toLowerCase().includes(normalizedQuery.toLowerCase())) {
+            const matchStart = valueString.toLowerCase().indexOf(normalizedQuery.toLowerCase());
+            const matchEnd = matchStart + normalizedQuery.length;
+            result.matches.push({
+              key,
+              prefix: this.truncate(
+                valueString.substring(0, matchStart),
+                "start"
+              ),
+              match: valueString.substring(matchStart, matchEnd),
+              suffix: this.truncate(
+                valueString.substring(matchEnd, valueString.length),
+                "end"
+              )
+            });
+          }
+        }
+        if (result.matches.length > 0) {
+          results.push(result);
+        }
+      });
+    });
+    return results;
+  }
+  truncate(value, at, limit = 15) {
+    if (at === "start") {
+      return `${value.substring(value.length - limit, value.length)}`;
+    } else {
+      return `${value.substring(0, limit)}`;
+    }
+  }
+};
+
+// src/service/ProjectService.ts
+var ProjectService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, userService, gitService, searchService, assetService, collectionService, entryService, valueService) {
+    super(serviceTypeSchema8.Enum.Project, options);
+    this.jsonFileService = jsonFileService;
+    this.userService = userService;
+    this.gitService = gitService;
+    this.searchService = searchService;
+    this.assetService = assetService;
+    this.collectionService = collectionService;
+    this.entryService = entryService;
+    this.valueService = valueService;
+  }
+  /**
+   * Creates a new Project
+   */
+  async create(props) {
+    createProjectSchema.parse(props);
+    const user = await this.userService.get();
+    if (!user) {
+      throw new NoCurrentUserError();
+    }
+    const id = uuid6();
+    const defaultSettings = {
+      locale: {
+        default: user.locale,
+        supported: [user.locale]
+      }
+    };
+    const projectFile = {
+      ...props,
+      fileType: "project",
+      id,
+      description: props.description || "",
+      settings: Object.assign({}, defaultSettings, props.settings),
+      created: currentTimestamp5(),
+      coreVersion: this.options.version,
+      // @todo should be read from package.json to avoid duplicates
+      status: "todo",
+      version: "0.0.1"
+    };
+    const projectPath = pathTo.project(id);
+    await Fs7.ensureDir(projectPath);
+    try {
+      await this.createFolderStructure(projectPath);
+      await this.createGitignore(projectPath);
+      await this.gitService.init(projectPath, { initialBranch: "main" });
+      await this.jsonFileService.create(
+        projectFile,
+        pathTo.projectFile(id),
+        projectFileSchema
+      );
+      await this.gitService.add(projectPath, ["."]);
+      await this.gitService.commit(
+        projectPath,
+        `${gitCommitIconSchema2.enum.INIT} Created this new elek.io project`
+      );
+      await this.gitService.switch(projectPath, "stage", { isNew: true });
+    } catch (error) {
+      await this.delete({
+        id
+      });
+      throw error;
+    }
+    return projectFile;
+  }
+  /**
+   * Returns a Project by ID
+   */
+  async read(props) {
+    readProjectSchema.parse(props);
+    const projectFile = await this.jsonFileService.read(
+      pathTo.projectFile(props.id),
+      projectFileSchema
+    );
+    return projectFile;
+  }
+  /**
+   * Updates given Project
+   */
+  async update(props) {
+    updateProjectSchema.parse(props);
+    const projectPath = pathTo.project(props.id);
+    const filePath = pathTo.projectFile(props.id);
+    const prevProjectFile = await this.read(props);
+    const projectFile = {
+      ...prevProjectFile,
+      ...props,
+      updated: currentTimestamp5()
+    };
+    await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
+    await this.gitService.add(projectPath, [filePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return projectFile;
+  }
+  /**
+   * Upgrades given Project to the latest version of this client
+   *
+   * Needed when a new core version is requiring changes to existing files or structure.
+   *
+   * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
+   */
+  async upgrade(props) {
+    upgradeProjectSchema.parse(props);
+    const project = await this.read(props);
+    const projectPath = pathTo.project(project.id);
+    if (Semver.gt(project.coreVersion, this.options.version)) {
+      throw new Error(
+        `Failed upgrading project. The projects core version "${project.coreVersion}" is higher than the current core version "${this.options.version}" of this client. A client upgrade is needed beforehand.`
+      );
+    }
+    if (Semver.eq(project.coreVersion, this.options.version)) {
+      return;
+    }
+    const upgradeFiles = await files(
+      Path2.resolve(__dirname, "../upgrade"),
+      "ts"
+    );
+    const upgrades = (await Promise.all(
+      upgradeFiles.map((file) => {
+        return import(Path2.join("../upgrade", file.name));
+      })
+    )).map((upgradeImport) => {
+      return upgradeImport.default;
+    });
+    const sortedUpgrades = upgrades.sort((a, b) => {
+      return Semver.compare(a.to, b.to);
+    }).filter((upgrade) => {
+      if (upgrade.to !== "0.0.0") {
+        return upgrade;
+      }
+    });
+    for (let index = 0; index < sortedUpgrades.length; index++) {
+      const upgrade = sortedUpgrades[index];
+      if (!upgrade) {
+        throw new Error("Expected ProjectUpgrade but got undefined");
+      }
+      const failsafeTag = await this.gitService.tags.create({
+        path: projectPath,
+        message: `Attempting to upgrade Project to Core version "${upgrade.to}"`
+      });
+      try {
+        await upgrade.run(project);
+        project.coreVersion = upgrade.to;
+        await this.update(project);
+        await this.gitService.tags.create({
+          path: projectPath,
+          message: `Upgraded Project to Core version "${upgrade.to}"`
+        });
+        await this.gitService.tags.delete({
+          path: projectPath,
+          id: failsafeTag.id
+        });
+      } catch (error) {
+        await this.gitService.reset(projectPath, "hard", failsafeTag.id);
+        throw new ProjectUpgradeError(
+          `Failed to upgrade Project to Core version "${upgrade.to}"`
+        );
+      }
+    }
+  }
+  /**
+   * Deletes given Project
+   *
+   * Deletes the whole Project folder including the history, not only the config file.
+   * Use with caution, since a Project that is only available locally could be lost forever.
+   * Or changes that are not pushed to a remote yet, will be lost too.
+   */
+  async delete(props) {
+    deleteProjectSchema.parse(props);
+    await Fs7.remove(pathTo.project(props.id));
+  }
+  async list(props) {
+    if (props) {
+      listProjectsSchema.parse(props);
+    }
+    const references = await this.listReferences(fileTypeSchema6.Enum.project);
+    const list = await returnResolved(
+      references.map((reference) => {
+        return this.read({ id: reference.id });
+      })
+    );
+    return this.paginate(
+      list,
+      props?.sort,
+      props?.filter,
+      props?.limit,
+      props?.offset
+    );
+  }
+  async count() {
+    return (await this.listReferences(fileTypeSchema6.Enum.project)).length;
+  }
+  /**
+   * Search all models inside the project for given query
+   *
+   * @param projectId Project ID to search in
+   * @param query     Query to search for
+   * @param type      (Optional) specify the type to search for
+   */
+  async search(projectId, query, type) {
+    return this.searchService.search(projectId, query, type);
+  }
+  /**
+   * Checks if given object is of type Project
+   */
+  isProject(obj) {
+    return projectFileSchema.safeParse(obj).success;
+  }
+  /**
+   * Exports given Project to JSON
+   *
+   * @todo performance tests
+   * @todo add progress callback
+   */
+  async exportToJson(projectId) {
+    const project = await this.read({ id: projectId });
+    const assets = (await this.assetService.list({ projectId, limit: 0 })).list;
+    const collections = (await this.collectionService.list({ projectId, limit: 0 })).list;
+    const collectionExport = await Promise.all(
+      collections.map(async (collection) => {
+        const entries = (await this.entryService.list({
+          projectId,
+          collectionId: collection.id,
+          limit: 0
+        })).list;
+        const entryExport = await Promise.all(
+          entries.map(async (entry) => {
+            const valueExport = await Promise.all(
+              entry.valueReferences.map(async (valueReference) => {
+                return this.valueService.read({
+                  projectId,
+                  id: valueReference.references.id,
+                  language: valueReference.references.language
+                });
+              })
+            );
+            return {
+              ...entry,
+              values: valueExport
+            };
+          })
+        );
+        return {
+          ...collection,
+          entries: entryExport
+        };
+      })
+    );
+    return {
+      ...project,
+      assets,
+      collections: collectionExport
+    };
+  }
+  /**
+   * Creates the projects folder structure and makes sure to
+   * write empty .gitkeep files inside them to ensure they are
+   * committed
+   */
+  async createFolderStructure(path) {
+    const folders2 = Object.values(projectFolderSchema2.Values);
+    await Promise.all(
+      folders2.map(async (folder) => {
+        await Fs7.mkdirp(Path2.join(path, folder));
+        await Fs7.writeFile(Path2.join(path, folder, ".gitkeep"), "");
+      })
+    );
+  }
+  /**
+   * Writes the Projects main .gitignore file to disk
+   *
+   * @todo Add general things to ignore
+   * @see https://github.com/github/gitignore/tree/master/Global
+   */
+  async createGitignore(path) {
+    const lines = [
+      "# Ignore all hidden files and folders...",
+      ".*",
+      "# ...but these",
+      "!/.gitignore",
+      "!/.gitattributes",
+      "!/**/.gitkeep",
+      "",
+      "# elek.io related ignores"
+      // projectFolderSchema.Enum.theme + '/',
+      // projectFolderSchema.Enum.public + '/',
+      // projectFolderSchema.Enum.logs + '/',
+    ];
+    await Fs7.writeFile(Path2.join(path, ".gitignore"), lines.join(Os2.EOL));
+  }
+};
+
+// src/index.ts
+var ElekIoCore = class {
+  constructor(props) {
+    if (props) {
+      constructorElekIoCoreSchema.parse(props);
+    }
+    const environment = environmentSchema.parse(process.env.NODE_ENV);
+    const defaults = {
+      environment,
+      version: "0.0.0",
+      file: {
+        json: {
+          indentation: 2
+        }
+      }
+    };
+    this.options = Object.assign({}, defaults, props);
+    this.jsonFileService = new JsonFileService(this.options);
+    this.userService = new UserService(this.jsonFileService);
+    this.gitService = new GitService2(this.options, this.userService);
+    this.assetService = new AssetService(
+      this.options,
+      this.jsonFileService,
+      this.gitService
+    );
+    this.valueService = new ValueService(
+      this.options,
+      this.jsonFileService,
+      this.gitService,
+      this.assetService
+    );
+    this.collectionService = new CollectionService(
+      this.options,
+      this.jsonFileService,
+      this.gitService
+    );
+    this.entryService = new EntryService(
+      this.options,
+      this.jsonFileService,
+      this.gitService,
+      this.collectionService,
+      this.valueService
+    );
+    this.searchService = new SearchService(
+      this.options,
+      this.assetService,
+      this.collectionService
+    );
+    this.projectService = new ProjectService(
+      this.options,
+      this.jsonFileService,
+      this.userService,
+      this.gitService,
+      this.searchService,
+      this.assetService,
+      this.collectionService,
+      this.entryService,
+      this.valueService
+    );
+    if (environment !== "production") {
+      console.info(`Initializing inside an "${environment}" environment`, {
+        options: this.options
+      });
+    }
+    Fs8.mkdirpSync(pathTo.projects);
+    Fs8.mkdirpSync(pathTo.tmp);
+    Fs8.emptyDirSync(pathTo.tmp);
+  }
+  /**
+   * Utility / helper functions
+   */
+  get util() {
+    return util_exports;
+  }
+  /**
+   *
+   */
+  get user() {
+    return this.userService;
+  }
+  /**
+   * CRUD methods to work with Projects
+   */
+  get projects() {
+    return this.projectService;
+  }
+  /**
+   * CRUD methods to work with Assets
+   */
+  get assets() {
+    return this.assetService;
+  }
+  /**
+   * CRUD methods to work with Collections
+   */
+  get collections() {
+    return this.collectionService;
+  }
+  /**
+   * CRUD methods to work with Entries
+   */
+  get entries() {
+    return this.entryService;
+  }
+  /**
+   * CRUD methods to work with Values
+   */
+  get values() {
+    return this.valueService;
+  }
+};
+export {
+  ElekIoCore as default
+};
+//# sourceMappingURL=index.js.map