@elek-io/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2177 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => ElekIoCore
+});
+module.exports = __toCommonJS(src_exports);
+var import_shared13 = require("@elek-io/shared");
+var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+
+// src/service/AssetService.ts
+var import_shared7 = require("@elek-io/shared");
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_is_svg = __toESM(require("is-svg"), 1);
+
+// 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
+});
+var import_shared = require("@elek-io/shared");
+var import_child_process = require("child_process");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_lodash_es = require("lodash-es");
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var workingDirectory = import_path.default.join(import_os.default.homedir(), "elek.io");
+var pathTo = {
+  tmp: import_path.default.join(workingDirectory, "tmp"),
+  userFile: import_path.default.join(workingDirectory, "user.json"),
+  // logs: Path.join(workingDirectory, 'logs'),
+  projects: import_path.default.join(workingDirectory, "projects"),
+  project: (projectId) => {
+    return import_path.default.join(pathTo.projects, projectId);
+  },
+  projectFile: (projectId) => {
+    return import_path.default.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 import_path.default.join(pathTo.project(projectId), import_shared.projectFolderSchema.Enum.lfs);
+  },
+  collections: (projectId) => {
+    return import_path.default.join(
+      pathTo.project(projectId),
+      import_shared.projectFolderSchema.Enum.collections
+    );
+  },
+  collection: (projectId, id) => {
+    return import_path.default.join(pathTo.collections(projectId), id);
+  },
+  collectionFile: (projectId, id) => {
+    return import_path.default.join(pathTo.collection(projectId, id), "collection.json");
+  },
+  entries: (projectId, collectionId) => {
+    return import_path.default.join(pathTo.collection(projectId, collectionId));
+  },
+  entryFile: (projectId, collectionId, id, language) => {
+    return import_path.default.join(
+      pathTo.entries(projectId, collectionId),
+      `${id}.${language}.json`
+    );
+  },
+  values: (projectId) => {
+    return import_path.default.join(pathTo.project(projectId), "values");
+  },
+  valueFile: (projectId, id, language) => {
+    return import_path.default.join(pathTo.values(projectId), `${id}.${language}.json`);
+  },
+  assets: (projectId) => {
+    return import_path.default.join(
+      pathTo.project(projectId),
+      import_shared.projectFolderSchema.Enum.assets
+    );
+  },
+  assetFile: (projectId, id, language) => {
+    return import_path.default.join(pathTo.assets(projectId), `${id}.${language}.json`);
+  },
+  asset: (projectId, id, language, extension) => {
+    return import_path.default.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 && import_shared.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 = (0, import_child_process.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 import_fs_extra.default.readdir(path, { withFileTypes: true });
+  return dirent.filter((dirent2) => {
+    return dirent2.isDirectory();
+  });
+}
+async function files(path, extension) {
+  const dirent = await import_fs_extra.default.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 = (0, import_lodash_es.groupBy)(arr, (item) => {
+    return item[key];
+  });
+  return (0, import_lodash_es.uniq)(
+    (0, import_lodash_es.flatten)(
+      (0, import_lodash_es.filter)(grouped, (item) => {
+        return item.length > 1;
+      })
+    )
+  );
+}
+
+// src/service/AbstractCrudService.ts
+var import_shared2 = require("@elek-io/shared");
+var import_lodash_es2 = require("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: `${import_shared2.gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
+      update: `${import_shared2.gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
+      delete: `${import_shared2.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 !== "") {
+      (0, import_lodash_es2.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 = (0, import_lodash_es2.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 import_shared2.fileTypeSchema.Enum.asset:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        return this.getFileReferences(pathTo.lfs(projectId));
+      case import_shared2.fileTypeSchema.Enum.project:
+        return this.getFolderReferences(pathTo.projects);
+      case import_shared2.fileTypeSchema.Enum.collection:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        return this.getFolderReferences(pathTo.collections(projectId));
+      case import_shared2.fileTypeSchema.Enum.entry:
+        if (!projectId) {
+          throw new RequiredParameterMissingError("projectId");
+        }
+        if (!collectionId) {
+          throw new RequiredParameterMissingError("collectionId");
+        }
+        return this.getFileReferences(
+          pathTo.collection(projectId, collectionId)
+        );
+      case import_shared2.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 import_shared2.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 import_shared2.fileReferenceSchema.parse(fileReference);
+        } catch (error) {
+          return null;
+        }
+      })
+    );
+    return results.filter(notEmpty);
+  }
+};
+
+// src/service/GitService.ts
+var import_shared6 = require("@elek-io/shared");
+var import_dugite = require("dugite");
+var import_p_queue = __toESM(require("p-queue"), 1);
+
+// 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
+var import_shared3 = require("@elek-io/shared");
+var GitTagService = class extends AbstractCrudService {
+  constructor(options, git) {
+    super(import_shared3.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) {
+    import_shared3.createGitTagSchema.parse(props);
+    const id = (0, import_shared3.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) {
+    import_shared3.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) {
+    import_shared3.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) {
+    import_shared3.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) {
+    import_shared3.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 import_shared3.gitTagSchema.safeParse(obj).success;
+  }
+};
+
+// src/service/UserService.ts
+var import_shared5 = require("@elek-io/shared");
+
+// src/service/JsonFileService.ts
+var import_shared4 = require("@elek-io/shared");
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var JsonFileService = class extends AbstractCrudService {
+  constructor(options) {
+    super(import_shared4.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 import_fs_extra2.default.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 import_fs_extra2.default.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 import_fs_extra2.default.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,
+        import_shared5.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) {
+    import_shared5.setUserSchema.parse(props);
+    const userFilePath = pathTo.userFile;
+    const userFile = {
+      ...props
+    };
+    if (userFile.userType === import_shared5.UserTypeSchema.Enum.cloud) {
+    }
+    await this.jsonFileService.update(userFile, userFilePath, import_shared5.userFileSchema);
+    return userFile;
+  }
+};
+
+// src/service/GitService.ts
+var GitService2 = class {
+  constructor(options, userService) {
+    this.version = void 0;
+    this.queue = new import_p_queue.default({
+      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() === "" || import_shared6.uuidSchema.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 import_shared6.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(() => import_dugite.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(import_shared7.serviceTypeSchema.Enum.Asset, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Asset
+   */
+  async create(props) {
+    import_shared7.createAssetSchema.parse(props);
+    const id = (0, import_shared7.uuid)();
+    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: (0, import_shared7.currentTimestamp)(),
+      extension: fileType.extension,
+      mimeType: fileType.mimeType,
+      size
+    };
+    try {
+      await import_fs_extra3.default.copyFile(props.filePath, assetPath);
+      await this.jsonFileService.create(
+        assetFile,
+        assetFilePath,
+        import_shared7.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) {
+    import_shared7.readAssetSchema.parse(props);
+    const assetFile = await this.jsonFileService.read(
+      pathTo.assetFile(props.projectId, props.id, props.language),
+      import_shared7.assetFileSchema
+    );
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Updates given Asset
+   *
+   * Use the optional "newFilePath" prop to update the Asset itself
+   */
+  async update(props) {
+    import_shared7.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: (0, import_shared7.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 import_fs_extra3.default.remove(prevAssetPath);
+      await import_fs_extra3.default.copyFile(props.newFilePath, assetPath);
+      assetFile.extension = fileType.extension;
+      assetFile.mimeType = fileType.mimeType;
+      assetFile.size = size;
+    }
+    await this.jsonFileService.update(
+      assetFile,
+      assetFilePath,
+      import_shared7.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) {
+    import_shared7.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 import_fs_extra3.default.remove(assetPath);
+    await import_fs_extra3.default.remove(assetFilePath);
+    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    import_shared7.listAssetsSchema.parse(props);
+    const assetReferences = await this.listReferences(
+      import_shared7.fileTypeSchema.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) {
+    import_shared7.countAssetsSchema.parse(props);
+    const count = (await this.listReferences(import_shared7.fileTypeSchema.Enum.asset, props.projectId)).length;
+    return count;
+  }
+  /**
+   * Checks if given object is of type Asset
+   */
+  isAsset(obj) {
+    return import_shared7.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 import_fs_extra3.default.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 import_fs_extra3.default.stat(filePath)).size;
+    if (fileSize / 1e3 <= 500) {
+      const fileBuffer = await import_fs_extra3.default.readFile(filePath);
+      if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
+        return {
+          extension: import_shared7.supportedExtensionSchema.Enum.svg,
+          mimeType: import_shared7.supportedMimeTypeSchema.Enum["image/svg+xml"]
+        };
+      }
+    }
+    const { fileTypeFromFile } = await import("file-type");
+    const fileType = await fileTypeFromFile(filePath);
+    const result = import_shared7.supportedFileTypeSchema.parse({
+      extension: fileType?.ext,
+      mimeType: fileType?.mime
+    });
+    return result;
+  }
+};
+
+// src/service/CollectionService.ts
+var import_shared8 = require("@elek-io/shared");
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var CollectionService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService) {
+    super(import_shared8.serviceTypeSchema.Enum.Collection, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Collection
+   */
+  async create(props) {
+    import_shared8.createCollectionSchema.parse(props);
+    const id = (0, import_shared8.uuid)();
+    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: (0, import_shared8.slug)(props.slug.singular),
+        plural: (0, import_shared8.slug)(props.slug.plural)
+      },
+      created: (0, import_shared8.currentTimestamp)()
+    };
+    await import_fs_extra4.default.ensureDir(collectionPath);
+    await this.jsonFileService.create(
+      collectionFile,
+      collectionFilePath,
+      import_shared8.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) {
+    import_shared8.readCollectionSchema.parse(props);
+    const collection = await this.jsonFileService.read(
+      pathTo.collectionFile(props.projectId, props.id),
+      import_shared8.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) {
+    import_shared8.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: (0, import_shared8.currentTimestamp)()
+    };
+    await this.jsonFileService.update(
+      collectionFile,
+      collectionFilePath,
+      import_shared8.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) {
+    import_shared8.deleteCollectionSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const collectionPath = pathTo.collection(
+      props.projectId,
+      props.id
+    );
+    await import_fs_extra4.default.remove(collectionPath);
+    await this.gitService.add(projectPath, [collectionPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    import_shared8.listCollectionsSchema.parse(props);
+    const references = await this.listReferences(
+      import_shared8.fileTypeSchema.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) {
+    import_shared8.countCollectionsSchema.parse(props);
+    const count = (await this.listReferences(import_shared8.fileTypeSchema.Enum.collection, props.projectId)).length;
+    return count;
+  }
+  /**
+   * Checks if given object is of type Collection
+   */
+  isCollection(obj) {
+    return import_shared8.collectionFileSchema.safeParse(obj).success;
+  }
+};
+
+// src/service/EntryService.ts
+var import_shared10 = require("@elek-io/shared");
+var import_fs_extra6 = __toESM(require("fs-extra"), 1);
+
+// src/service/ValueService.ts
+var import_shared9 = require("@elek-io/shared");
+var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+var ValueService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService, assetService) {
+    super(import_shared9.serviceTypeSchema.Enum.Value, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+  }
+  /**
+   * Creates a new Value
+   */
+  async create(props) {
+    import_shared9.createValueSchema.parse(props);
+    const id = (0, import_shared9.uuid)();
+    const projectPath = pathTo.project(props.projectId);
+    const valueFilePath = pathTo.valueFile(
+      props.projectId,
+      id,
+      props.language
+    );
+    const valueFile = {
+      ...props,
+      fileType: "value",
+      id,
+      created: (0, import_shared9.currentTimestamp)()
+    };
+    await this.jsonFileService.create(
+      valueFile,
+      valueFilePath,
+      import_shared9.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) {
+    import_shared9.readValueSchema.parse(props);
+    const valueFile = await this.jsonFileService.read(
+      pathTo.valueFile(props.projectId, props.id, props.language),
+      import_shared9.valueFileSchema
+    );
+    return valueFile;
+  }
+  /**
+   * Updates given Value
+   */
+  async update(props) {
+    import_shared9.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: (0, import_shared9.currentTimestamp)()
+    };
+    await this.jsonFileService.update(
+      valueFile,
+      valueFilePath,
+      import_shared9.valueFileSchema
+    );
+    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return valueFile;
+  }
+  /**
+   * Deletes given Value
+   */
+  async delete(props) {
+    import_shared9.deleteValueSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const valueFilePath = pathTo.valueFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    await import_fs_extra5.default.remove(valueFilePath);
+    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    import_shared9.listValuesSchema.parse(props);
+    const references = await this.listReferences(
+      import_shared9.fileTypeSchema.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) {
+    import_shared9.countValuesSchema.parse(props);
+    const count = (await this.listReferences(import_shared9.fileTypeSchema.Enum.value, props.projectId)).length;
+    return count;
+  }
+  /**
+   * Checks if given object is of type Value
+   */
+  isValue(obj) {
+    return import_shared9.valueFileSchema.safeParse(obj).success;
+  }
+  /**
+   * Reads the given Value from disk and validates it against the ValueDefinition
+   */
+  async validate(props) {
+    import_shared9.validateValueSchema.parse(props);
+    const value = await this.read(props);
+    const valueSchema = (0, import_shared9.getValueSchemaFromDefinition)(props.definition);
+    return valueSchema.safeParse(value.content);
+  }
+};
+
+// src/service/EntryService.ts
+var EntryService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService, collectionService, valueService) {
+    super(import_shared10.serviceTypeSchema.Enum.Entry, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
+    this.collectionService = collectionService;
+    this.valueService = valueService;
+  }
+  /**
+   * Creates a new Entry
+   */
+  async create(props) {
+    import_shared10.createEntrySchema.parse(props);
+    const id = (0, import_shared10.uuid)();
+    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: (0, import_shared10.currentTimestamp)()
+    };
+    await this.jsonFileService.create(
+      entryFile,
+      entryFilePath,
+      import_shared10.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) {
+    import_shared10.readEntrySchema.parse(props);
+    const entryFile = await this.jsonFileService.read(
+      pathTo.entryFile(
+        props.projectId,
+        props.collectionId,
+        props.id,
+        props.language
+      ),
+      import_shared10.entryFileSchema
+    );
+    return entryFile;
+  }
+  /**
+   * Updates Entry with given ValueReferences
+   */
+  async update(props) {
+    import_shared10.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: (0, import_shared10.currentTimestamp)()
+    };
+    await this.jsonFileService.update(
+      entryFile,
+      entryFilePath,
+      import_shared10.entryFileSchema
+    );
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return entryFile;
+  }
+  /**
+   * Deletes given Entry
+   */
+  async delete(props) {
+    import_shared10.deleteEntrySchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const entryFilePath = pathTo.entryFile(
+      props.projectId,
+      props.collectionId,
+      props.id,
+      props.language
+    );
+    await import_fs_extra6.default.remove(entryFilePath);
+    await this.gitService.add(projectPath, [entryFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
+  async list(props) {
+    import_shared10.listEntriesSchema.parse(props);
+    const references = await this.listReferences(
+      import_shared10.fileTypeSchema.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) {
+    import_shared10.countEntriesSchema.parse(props);
+    return (await this.listReferences(
+      import_shared10.fileTypeSchema.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 import_shared10.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 = (0, import_shared10.getValueSchemaFromDefinition)(definition);
+        const value = await this.valueService.read({
+          ...reference.references,
+          projectId
+        });
+        schema.parse(value.content);
+      })
+    );
+  }
+};
+
+// src/service/ProjectService.ts
+var import_shared12 = require("@elek-io/shared");
+var import_fs_extra7 = __toESM(require("fs-extra"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_semver = __toESM(require("semver"), 1);
+
+// src/error/ProjectUpgradeError.ts
+var ProjectUpgradeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectUpgradeError";
+  }
+};
+
+// src/service/SearchService.ts
+var import_shared11 = require("@elek-io/shared");
+var SearchService = class extends AbstractCrudService {
+  constructor(options, assetService, collectionService) {
+    super(import_shared11.serviceTypeSchema.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(import_shared12.serviceTypeSchema.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) {
+    import_shared12.createProjectSchema.parse(props);
+    const user = await this.userService.get();
+    if (!user) {
+      throw new NoCurrentUserError();
+    }
+    const id = (0, import_shared12.uuid)();
+    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: (0, import_shared12.currentTimestamp)(),
+      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 import_fs_extra7.default.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),
+        import_shared12.projectFileSchema
+      );
+      await this.gitService.add(projectPath, ["."]);
+      await this.gitService.commit(
+        projectPath,
+        `${import_shared12.gitCommitIconSchema.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) {
+    import_shared12.readProjectSchema.parse(props);
+    const projectFile = await this.jsonFileService.read(
+      pathTo.projectFile(props.id),
+      import_shared12.projectFileSchema
+    );
+    return projectFile;
+  }
+  /**
+   * Updates given Project
+   */
+  async update(props) {
+    import_shared12.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: (0, import_shared12.currentTimestamp)()
+    };
+    await this.jsonFileService.update(projectFile, filePath, import_shared12.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) {
+    import_shared12.upgradeProjectSchema.parse(props);
+    const project = await this.read(props);
+    const projectPath = pathTo.project(project.id);
+    if (import_semver.default.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 (import_semver.default.eq(project.coreVersion, this.options.version)) {
+      return;
+    }
+    const upgradeFiles = await files(
+      import_path2.default.resolve(__dirname, "../upgrade"),
+      "ts"
+    );
+    const upgrades = (await Promise.all(
+      upgradeFiles.map((file) => {
+        return import(import_path2.default.join("../upgrade", file.name));
+      })
+    )).map((upgradeImport) => {
+      return upgradeImport.default;
+    });
+    const sortedUpgrades = upgrades.sort((a, b) => {
+      return import_semver.default.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) {
+    import_shared12.deleteProjectSchema.parse(props);
+    await import_fs_extra7.default.remove(pathTo.project(props.id));
+  }
+  async list(props) {
+    if (props) {
+      import_shared12.listProjectsSchema.parse(props);
+    }
+    const references = await this.listReferences(import_shared12.fileTypeSchema.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(import_shared12.fileTypeSchema.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 import_shared12.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(import_shared12.projectFolderSchema.Values);
+    await Promise.all(
+      folders2.map(async (folder) => {
+        await import_fs_extra7.default.mkdirp(import_path2.default.join(path, folder));
+        await import_fs_extra7.default.writeFile(import_path2.default.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 import_fs_extra7.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os2.default.EOL));
+  }
+};
+
+// src/index.ts
+var ElekIoCore = class {
+  constructor(props) {
+    if (props) {
+      import_shared13.constructorElekIoCoreSchema.parse(props);
+    }
+    const environment = import_shared13.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
+      });
+    }
+    import_fs_extra8.default.mkdirpSync(pathTo.projects);
+    import_fs_extra8.default.mkdirpSync(pathTo.tmp);
+    import_fs_extra8.default.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;
+  }
+};
+//# sourceMappingURL=index.cjs.map