@elek-io/core 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -33,11 +33,9 @@ __export(src_exports, {
   default: () => ElekIoCore
 });
 module.exports = __toCommonJS(src_exports);
-var import_shared12 = require("@elek-io/shared");
 var import_fs_extra7 = __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);
 
@@ -49,10 +47,332 @@ var RequiredParameterMissingError = class extends Error {
   }
 };
 
+// src/schema/assetSchema.ts
+var import_zod3 = __toESM(require("zod"), 1);
+
+// src/schema/baseSchema.ts
+var import_zod = __toESM(require("zod"), 1);
+var environmentSchema = import_zod.default.enum(["production", "development", "test"]);
+var supportedLanguageSchema = import_zod.default.enum([
+  /**
+   * Bulgarian
+   */
+  "bg",
+  //
+  "cs",
+  // Czech
+  "da",
+  // Danish
+  "de",
+  // German
+  "el",
+  // Greek
+  "en",
+  // (US) English
+  "es",
+  // Spanish
+  "et",
+  // Estonian
+  "fi",
+  // Finnish
+  "fr",
+  // French
+  "hu",
+  // Hungarian
+  "it",
+  // Italian
+  "ja",
+  // Japanese
+  "lt",
+  // Lithuanian
+  "lv",
+  // Latvian
+  "nl",
+  // Dutch
+  "pl",
+  // Polish
+  "pt",
+  // Portuguese
+  "ro",
+  // Romanian
+  "ru",
+  // Russian
+  "sk",
+  // Slovak
+  "sl",
+  // Slovenian
+  "sv",
+  // Swedish
+  "zh"
+  // (Simplified) Chinese
+]);
+var supportedIconSchema = import_zod.default.enum(["home", "plus", "foobar"]);
+var supportedAssetMimeTypeSchema = import_zod.default.enum([
+  "image/avif",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp",
+  "application/pdf",
+  "application/zip",
+  "video/mp4",
+  "video/webm",
+  "audio/webm",
+  "audio/flac"
+]);
+var supportedAssetExtensionSchema = import_zod.default.enum([
+  "avif",
+  "gif",
+  "jpg",
+  "jpeg",
+  "png",
+  "svg",
+  "webp",
+  "pdf",
+  "zip",
+  "mp4",
+  "webm",
+  "flac",
+  "json"
+]);
+var supportedAssetTypeSchema = import_zod.default.object({
+  extension: supportedAssetExtensionSchema,
+  mimeType: supportedAssetMimeTypeSchema
+});
+var objectTypeSchema = import_zod.default.enum([
+  "project",
+  "asset",
+  "collection",
+  "entry",
+  "value",
+  "sharedValue"
+]);
+var versionSchema = import_zod.default.string();
+var uuidSchema = import_zod.default.string().uuid("shared.invalidUuid");
+var translatableStringSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.string().trim().min(1, "shared.translatableStringRequired")
+);
+var translatableNumberSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.number({ required_error: "shared.translatableNumberRequired" })
+);
+var translatableBooleanSchema = import_zod.default.record(
+  supportedLanguageSchema,
+  import_zod.default.boolean({ required_error: "shared.translatableBooleanRequired" })
+);
+function translatableArrayOf(schema) {
+  return import_zod.default.record(supportedLanguageSchema, import_zod.default.array(schema));
+}
+
+// src/schema/fileSchema.ts
+var import_zod2 = __toESM(require("zod"), 1);
+var baseFileSchema = import_zod2.default.object({
+  /**
+   * The ID of the file
+   *
+   * The ID is part of the files name.
+   */
+  id: uuidSchema.readonly(),
+  /**
+   * The timestamp of the file being created is set by the service of "objectType" while creating it
+   */
+  created: import_zod2.default.number().readonly(),
+  /**
+   * The timestamp of the file being updated is set by the service of "objectType" while updating it
+   */
+  updated: import_zod2.default.number().nullable()
+});
+var baseFileWithLanguageSchema = baseFileSchema.extend({
+  /**
+   * The language of the file
+   *
+   * The language is part of the files name and together with it's ID the only unique identifier.
+   * That's why the language cannot be changed after creating the file.
+   *
+   * @todo Maybe remove the above restriction by implementing logic to handle changing the files language inside all services
+   */
+  language: supportedLanguageSchema.readonly()
+});
+var fileReferenceSchema = import_zod2.default.object({
+  id: uuidSchema,
+  language: supportedLanguageSchema.optional(),
+  extension: supportedAssetExtensionSchema.optional()
+});
+
+// src/schema/assetSchema.ts
+var assetFileSchema = baseFileWithLanguageSchema.extend({
+  objectType: import_zod3.default.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: import_zod3.default.string(),
+  description: import_zod3.default.string(),
+  extension: supportedAssetExtensionSchema.readonly(),
+  mimeType: supportedAssetMimeTypeSchema.readonly(),
+  /**
+   * Total size in bytes
+   */
+  size: import_zod3.default.number().readonly()
+});
+var assetSchema = assetFileSchema.extend({
+  /**
+   * Absolute path on this filesystem
+   */
+  absolutePath: import_zod3.default.string().readonly()
+});
+var assetExportSchema = assetSchema.extend({});
+var createAssetSchema = assetFileSchema.pick({
+  name: true,
+  description: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  /**
+   * Path of the file to add as a new Asset
+   */
+  filePath: import_zod3.default.string().readonly()
+});
+var readAssetSchema = assetFileSchema.pick({
+  id: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var updateAssetSchema = assetFileSchema.pick({
+  id: true,
+  name: true,
+  description: true,
+  language: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  /**
+   * Path of the new file to update the Asset with
+   */
+  newFilePath: import_zod3.default.string().readonly().optional()
+});
+var deleteAssetSchema = assetFileSchema.pick({
+  id: true,
+  language: true,
+  extension: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var countAssetsSchema = import_zod3.default.object({ projectId: uuidSchema.readonly() });
+
+// src/schema/serviceSchema.ts
+var import_zod5 = require("zod");
+
+// src/schema/gitSchema.ts
+var import_zod4 = require("zod");
+var gitRepositoryPathSchema = import_zod4.z.string();
+var gitSignatureSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  email: import_zod4.z.string()
+});
+var gitCommitSchema = import_zod4.z.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: import_zod4.z.string(),
+  message: import_zod4.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod4.z.number(),
+  tag: import_zod4.z.string().nullable()
+});
+var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
+  GitCommitIconNative2["INIT"] = ":tada:";
+  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
+  GitCommitIconNative2["UPDATE"] = ":wrench:";
+  GitCommitIconNative2["DELETE"] = ":fire:";
+  return GitCommitIconNative2;
+})(GitCommitIconNative || {});
+var gitCommitIconSchema = import_zod4.z.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = import_zod4.z.object({
+  /**
+   * Use the specified name for the initial branch in the newly created repository. If not specified, fall back to the default name (currently master, but this is subject to change in the future; the name can be customized via the init.defaultBranch configuration variable).
+   */
+  initialBranch: import_zod4.z.string()
+});
+var gitCloneOptionsSchema = import_zod4.z.object({
+  /**
+   * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
+   */
+  depth: import_zod4.z.number(),
+  /**
+   * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
+   */
+  singleBranch: import_zod4.z.boolean(),
+  /**
+   * Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository’s HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.
+   */
+  branch: import_zod4.z.string()
+});
+var gitSwitchOptionsSchema = import_zod4.z.object({
+  /**
+   * If true, creates a new local branch and then switches to it
+   *
+   * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
+   */
+  isNew: import_zod4.z.boolean().optional()
+});
+var gitLogOptionsSchema = import_zod4.z.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: import_zod4.z.number().optional(),
+  /**
+   * Only list commits that are between given SHAs or tag names
+   *
+   * Note that the commits of from and to are not included in the result
+   */
+  between: import_zod4.z.object({
+    /**
+     * From the oldest commit
+     */
+    from: import_zod4.z.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: import_zod4.z.string().optional()
+  })
+});
+
+// src/schema/serviceSchema.ts
+var serviceTypeSchema = import_zod5.z.enum([
+  "Git",
+  "GitTag",
+  "User",
+  "Project",
+  "Asset",
+  "JsonFile",
+  "Search",
+  "Collection",
+  "Entry",
+  "Value"
+]);
+var listSchema = import_zod5.z.object({
+  projectId: uuidSchema,
+  limit: import_zod5.z.number().optional(),
+  offset: import_zod5.z.number().optional()
+});
+var listCollectionsSchema = listSchema;
+var listEntriesSchema = listSchema.extend({
+  collectionId: uuidSchema
+});
+var listAssetsSchema = listSchema;
+var listProjectsSchema = listSchema.omit({
+  projectId: true
+});
+var listGitTagsSchema = import_zod5.z.object({
+  path: gitRepositoryPathSchema
+});
+
 // src/util/index.ts
 var util_exports = {};
 __export(util_exports, {
   assignDefaultIfMissing: () => assignDefaultIfMissing,
+  currentTimestamp: () => currentTimestamp,
   files: () => files,
   folders: () => folders,
   fromPath: () => fromPath,
@@ -62,15 +382,543 @@ __export(util_exports, {
   notEmpty: () => notEmpty,
   pathTo: () => pathTo,
   returnResolved: () => returnResolved,
+  slug: () => slug,
   spawnChildProcess: () => spawnChildProcess,
+  uuid: () => uuid,
   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 import_slugify = __toESM(require("slugify"), 1);
+var import_uuid = require("uuid");
+
+// src/schema/projectSchema.ts
+var import_zod9 = require("zod");
+
+// src/schema/collectionSchema.ts
+var import_zod8 = __toESM(require("zod"), 1);
+
+// src/schema/entrySchema.ts
+var import_zod7 = __toESM(require("zod"), 1);
+
+// src/schema/valueSchema.ts
+var import_zod6 = __toESM(require("zod"), 1);
+var ValueTypeSchema = import_zod6.default.enum([
+  "string",
+  "number",
+  "boolean",
+  "reference"
+]);
+var ValueInputTypeSchema = import_zod6.default.enum([
+  // String
+  "text",
+  "textarea",
+  "email",
+  // 'password', @todo maybe if there is a usecase
+  "url",
+  "ip",
+  "date",
+  "time",
+  "datetime",
+  "telephone",
+  // Number
+  "number",
+  "range",
+  // Boolean
+  "toggle",
+  // Reference
+  "asset",
+  "entry"
+  // 'sharedValue', // @todo
+]);
+var ValueInputWidthSchema = import_zod6.default.enum(["12", "6", "4", "3"]);
+var ValueDefinitionBaseSchema = import_zod6.default.object({
+  id: uuidSchema.readonly(),
+  label: translatableStringSchema,
+  description: translatableStringSchema,
+  isRequired: import_zod6.default.boolean(),
+  isDisabled: import_zod6.default.boolean(),
+  isUnique: import_zod6.default.boolean(),
+  inputWidth: ValueInputWidthSchema
+});
+var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: import_zod6.default.literal(ValueTypeSchema.Enum.string),
+    defaultValue: import_zod6.default.string().nullable()
+  }
+);
+var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.text),
+    min: import_zod6.default.number().nullable(),
+    max: import_zod6.default.number().nullable()
+  }
+);
+var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.textarea),
+  min: import_zod6.default.number().nullable(),
+  max: import_zod6.default.number().nullable()
+});
+var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.email),
+  defaultValue: import_zod6.default.string().email().nullable()
+});
+var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.url),
+  defaultValue: import_zod6.default.string().url().nullable()
+});
+var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.ip),
+  defaultValue: import_zod6.default.string().ip().nullable()
+});
+var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.date),
+    defaultValue: import_zod6.default.string().date().nullable()
+  }
+);
+var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
+  {
+    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.time),
+    defaultValue: import_zod6.default.string().time().nullable()
+  }
+);
+var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.datetime),
+  defaultValue: import_zod6.default.string().datetime().nullable()
+});
+var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.telephone)
+  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+});
+var stringValueDefinitionSchema = import_zod6.default.union([
+  textValueDefinitionSchema,
+  textareaValueDefinitionSchema,
+  emailValueDefinitionSchema,
+  urlValueDefinitionSchema,
+  ipValueDefinitionSchema,
+  dateValueDefinitionSchema,
+  timeValueDefinitionSchema,
+  datetimeValueDefinitionSchema,
+  telephoneValueDefinitionSchema
+]);
+var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
+  {
+    valueType: import_zod6.default.literal(ValueTypeSchema.Enum.number),
+    min: import_zod6.default.number().nullable(),
+    max: import_zod6.default.number().nullable(),
+    isUnique: import_zod6.default.literal(false),
+    defaultValue: import_zod6.default.number().nullable()
+  }
+);
+var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.number)
+});
+var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.range),
+  // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
+  isRequired: import_zod6.default.literal(true),
+  min: import_zod6.default.number(),
+  max: import_zod6.default.number(),
+  defaultValue: import_zod6.default.number()
+});
+var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.boolean),
+  // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
+  isRequired: import_zod6.default.literal(true),
+  defaultValue: import_zod6.default.boolean(),
+  isUnique: import_zod6.default.literal(false)
+});
+var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.toggle)
+});
+var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.reference)
+});
+var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.asset),
+  allowedMimeTypes: import_zod6.default.array(supportedAssetMimeTypeSchema).min(1),
+  min: import_zod6.default.number().nullable(),
+  max: import_zod6.default.number().nullable()
+});
+var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
+  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.entry),
+  ofCollections: import_zod6.default.array(uuidSchema),
+  min: import_zod6.default.number().nullable(),
+  max: import_zod6.default.number().nullable()
+});
+var valueDefinitionSchema = import_zod6.default.union([
+  stringValueDefinitionSchema,
+  numberValueDefinitionSchema,
+  rangeValueDefinitionSchema,
+  toggleValueDefinitionSchema,
+  assetValueDefinitionSchema,
+  entryValueDefinitionSchema
+  // sharedValueDefinitionSchema,
+]);
+var valueContentReferenceBase = import_zod6.default.object({
+  id: uuidSchema
+});
+var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
+  language: supportedLanguageSchema
+});
+var valueContentReferenceToAssetSchema = valueContentReferenceWithLanguageBase.extend({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.asset)
+});
+var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.collection)
+});
+var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.entry)
+});
+var valueContentReferenceSchema = import_zod6.default.union([
+  valueContentReferenceToAssetSchema,
+  valueContentReferenceToCollectionSchema,
+  valueContentReferenceToEntrySchema
+  // valueContentReferenceToSharedValueSchema,
+]);
+var resolvedValueContentReferenceSchema = import_zod6.default.union([
+  assetSchema,
+  import_zod6.default.lazy(() => entrySchema)
+  // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
+  // resolvedValueContentReferenceToSharedValueSchema,
+]);
+var directValueBaseSchema = import_zod6.default.object({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly()
+});
+var directStringValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.string).readonly(),
+  content: translatableStringSchema
+});
+var directNumberValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.number).readonly(),
+  content: translatableNumberSchema
+});
+var directBooleanValueSchema = directValueBaseSchema.extend({
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  content: translatableBooleanSchema
+});
+var directValueSchema = import_zod6.default.union([
+  directStringValueSchema,
+  directNumberValueSchema,
+  directBooleanValueSchema
+]);
+var referencedValueSchema = import_zod6.default.object({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.value).readonly(),
+  definitionId: uuidSchema.readonly(),
+  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.reference).readonly(),
+  content: translatableArrayOf(valueContentReferenceSchema)
+});
+var valueSchema = import_zod6.default.union([directValueSchema, referencedValueSchema]);
+var resolvedReferencedValueSchema = referencedValueSchema.extend({
+  content: translatableArrayOf(resolvedValueContentReferenceSchema)
+});
+var resolvedValueSchema = import_zod6.default.union([
+  directValueSchema,
+  resolvedReferencedValueSchema
+]);
+function getValueContentSchemaFromDefinition(definition) {
+  switch (definition.valueType) {
+    case ValueTypeSchema.Enum.boolean:
+      return getBooleanValueContentSchema(definition);
+    case ValueTypeSchema.Enum.number:
+      return getNumberValueContentSchema(definition);
+    case ValueTypeSchema.Enum.string:
+      return getStringValueContentSchema(definition);
+    case ValueTypeSchema.Enum.reference:
+      return getReferenceValueContentSchema(definition);
+    default:
+      throw new Error(
+        // @ts-expect-error
+        `Error generating schema for unsupported ValueType "${definition.valueType}"`
+      );
+  }
+}
+function getBooleanValueContentSchema(definition) {
+  return import_zod6.default.boolean();
+}
+function getNumberValueContentSchema(definition) {
+  let schema = import_zod6.default.number();
+  if (definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if (definition.max) {
+    schema = schema.max(definition.max);
+  }
+  if (definition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema;
+}
+function getStringValueContentSchema(definition) {
+  let schema = import_zod6.default.string().trim();
+  if ("min" in definition && definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if ("max" in definition && definition.max) {
+    schema = schema.max(definition.max);
+  }
+  switch (definition.inputType) {
+    case ValueInputTypeSchema.Enum.email:
+      schema = schema.email();
+      break;
+    case ValueInputTypeSchema.Enum.url:
+      schema = schema.url();
+      break;
+    case ValueInputTypeSchema.Enum.ip:
+      schema = schema.ip();
+      break;
+    case ValueInputTypeSchema.Enum.date:
+      schema = schema.date();
+      break;
+    case ValueInputTypeSchema.Enum.time:
+      schema = schema.time();
+      break;
+    case ValueInputTypeSchema.Enum.datetime:
+      schema = schema.datetime();
+      break;
+    case ValueInputTypeSchema.Enum.telephone:
+      break;
+  }
+  if (definition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema.min(1, "shared.stringValueRequired");
+}
+function getReferenceValueContentSchema(definition) {
+  let schema;
+  switch (definition.inputType) {
+    case ValueInputTypeSchema.Enum.asset:
+      {
+        schema = import_zod6.default.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case ValueInputTypeSchema.Enum.entry:
+      {
+        schema = import_zod6.default.array(valueContentReferenceToEntrySchema);
+      }
+      break;
+  }
+  if (definition.isRequired) {
+    schema = schema.min(1, "shared.referenceRequired");
+  }
+  if (definition.min) {
+    schema = schema.min(definition.min);
+  }
+  if (definition.max) {
+    schema = schema.max(definition.max);
+  }
+  return schema;
+}
+
+// src/schema/entrySchema.ts
+var entryFileSchema = baseFileSchema.extend({
+  objectType: import_zod7.default.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: import_zod7.default.array(valueSchema)
+});
+var entrySchema = entryFileSchema.extend({
+  values: import_zod7.default.array(import_zod7.default.lazy(() => resolvedValueSchema))
+});
+var entryExportSchema = entrySchema.extend({});
+var createEntrySchema = entryFileSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly(),
+  values: import_zod7.default.array(valueSchema)
+});
+var readEntrySchema = import_zod7.default.object({
+  id: uuidSchema.readonly(),
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var updateEntrySchema = entrySchema.omit({
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+var deleteEntrySchema = readEntrySchema.extend({});
+var countEntriesSchema = import_zod7.default.object({
+  projectId: uuidSchema.readonly(),
+  collectionId: uuidSchema.readonly()
+});
+
+// src/schema/collectionSchema.ts
+var collectionFileSchema = baseFileSchema.extend({
+  objectType: import_zod8.default.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: import_zod8.default.object({
+    singular: translatableStringSchema,
+    plural: translatableStringSchema
+  }),
+  slug: import_zod8.default.object({
+    singular: import_zod8.default.string(),
+    plural: import_zod8.default.string()
+  }),
+  description: translatableStringSchema,
+  icon: supportedIconSchema,
+  valueDefinitions: import_zod8.default.array(valueDefinitionSchema)
+});
+var collectionSchema = collectionFileSchema.extend({});
+var collectionExportSchema = collectionSchema.extend({
+  entries: import_zod8.default.array(entryExportSchema)
+});
+var createCollectionSchema = collectionSchema.omit({
+  id: true,
+  objectType: true,
+  created: true,
+  updated: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var readCollectionSchema = import_zod8.default.object({
+  id: uuidSchema.readonly(),
+  projectId: uuidSchema.readonly()
+});
+var updateCollectionSchema = collectionFileSchema.pick({
+  id: true,
+  name: true,
+  slug: true,
+  description: true,
+  icon: true,
+  valueDefinitions: true
+}).extend({
+  projectId: uuidSchema.readonly()
+});
+var deleteCollectionSchema = readCollectionSchema.extend({});
+var countCollectionsSchema = import_zod8.default.object({
+  projectId: uuidSchema.readonly()
+});
+
+// src/schema/projectSchema.ts
+var projectStatusSchema = import_zod9.z.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = import_zod9.z.object({
+  language: import_zod9.z.object({
+    default: supportedLanguageSchema,
+    supported: import_zod9.z.array(supportedLanguageSchema)
+  })
+});
+var projectFolderSchema = import_zod9.z.enum([
+  "assets",
+  "collections",
+  "shared-values",
+  "lfs"
+  // 'logs',
+  // 'public',
+  // 'theme',
+]);
+var projectFileSchema = baseFileSchema.extend({
+  objectType: import_zod9.z.literal(objectTypeSchema.Enum.project).readonly(),
+  coreVersion: versionSchema,
+  name: import_zod9.z.string().trim().min(1, "shared.projectNameRequired"),
+  description: import_zod9.z.string().trim().min(1, "shared.projectDescriptionRequired"),
+  version: versionSchema,
+  status: projectStatusSchema,
+  settings: projectSettingsSchema
+});
+var projectSchema = projectFileSchema.extend({});
+var projectExportSchema = projectSchema.extend({
+  assets: import_zod9.z.array(assetExportSchema),
+  collections: import_zod9.z.array(collectionExportSchema)
+});
+var createProjectSchema = projectSchema.pick({
+  name: true,
+  description: true,
+  settings: true
+}).partial({
+  description: true,
+  settings: true
+});
+var readProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var updateProjectSchema = projectSchema.pick({
+  id: true,
+  name: true,
+  description: true,
+  settings: true
+}).partial({
+  name: true,
+  description: true,
+  settings: true
+});
+var upgradeProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var deleteProjectSchema = readProjectSchema.extend({});
+var projectUpgradeSchema = import_zod9.z.object({
+  /**
+   * The Core version the Project will be upgraded to
+   */
+  to: versionSchema.readonly(),
+  /**
+   * Function that will be executed in the process of upgrading a Project
+   */
+  run: import_zod9.z.function().args(projectFileSchema).returns(import_zod9.z.promise(import_zod9.z.void()))
+});
+var cloneProjectSchema = import_zod9.z.object({
+  url: import_zod9.z.string()
+});
+var listBranchesProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var currentBranchProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var switchBranchProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly(),
+  branch: import_zod9.z.string(),
+  options: gitSwitchOptionsSchema.optional()
+});
+var getRemoteOriginUrlProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var setRemoteOriginUrlProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly(),
+  url: import_zod9.z.string()
+});
+var getChangesProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var synchronizeProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly()
+});
+var searchProjectSchema = import_zod9.z.object({
+  id: uuidSchema.readonly(),
+  query: import_zod9.z.string(),
+  language: supportedLanguageSchema,
+  type: import_zod9.z.array(objectTypeSchema).optional()
+});
+
+// src/util/index.ts
+var Slugify = import_slugify.default.default || import_slugify.default;
+function uuid() {
+  return (0, import_uuid.v4)();
+}
+function currentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function slug(string) {
+  return Slugify(string, {
+    replacement: "-",
+    // replace spaces with replacement character, defaults to `-`
+    remove: void 0,
+    // remove characters that match regex, defaults to `undefined`
+    lower: true,
+    // convert to lower case, defaults to `false`
+    strict: true
+    // strip special characters except replacement, defaults to `false`
+  });
+}
 var workingDirectory = import_path.default.join(import_os.default.homedir(), "elek.io");
 var pathTo = {
   tmp: import_path.default.join(workingDirectory, "tmp"),
@@ -90,12 +938,12 @@ var pathTo = {
   //   return Path.join(pathTo.project(projectId), 'public');
   // },
   lfs: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), import_shared.projectFolderSchema.Enum.lfs);
+    return import_path.default.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
   },
   collections: (projectId) => {
     return import_path.default.join(
       pathTo.project(projectId),
-      import_shared.projectFolderSchema.Enum.collections
+      projectFolderSchema.Enum.collections
     );
   },
   collection: (projectId, id) => {
@@ -119,7 +967,7 @@ var pathTo = {
   assets: (projectId) => {
     return import_path.default.join(
       pathTo.project(projectId),
-      import_shared.projectFolderSchema.Enum.assets
+      projectFolderSchema.Enum.assets
     );
   },
   assetFile: (projectId, id, language) => {
@@ -139,7 +987,7 @@ var fromPath = {
     }
     const end = path.indexOf(endsWith, start);
     const result = path.substring(start, end === -1 ? path.length : end);
-    if (result && import_shared.uuidSchema.safeParse(result).success) {
+    if (result && uuidSchema.safeParse(result).success) {
       return result;
     }
     return void 0;
@@ -240,8 +1088,6 @@ function getDuplicates(arr, key) {
 }
 
 // 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
@@ -250,56 +1096,9 @@ var AbstractCrudService = class {
     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
+      create: `${gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
+      update: `${gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
+      delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
     };
   }
   /**
@@ -311,19 +1110,19 @@ var AbstractCrudService = class {
    */
   async listReferences(type, projectId, collectionId) {
     switch (type) {
-      case import_shared2.objectTypeSchema.Enum.asset:
+      case objectTypeSchema.Enum.asset:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
-      case import_shared2.objectTypeSchema.Enum.project:
+      case objectTypeSchema.Enum.project:
         return this.getFolderReferences(pathTo.projects);
-      case import_shared2.objectTypeSchema.Enum.collection:
+      case objectTypeSchema.Enum.collection:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFolderReferences(pathTo.collections(projectId));
-      case import_shared2.objectTypeSchema.Enum.entry:
+      case objectTypeSchema.Enum.entry:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -333,7 +1132,7 @@ var AbstractCrudService = class {
         return this.getFileReferences(
           pathTo.collection(projectId, collectionId)
         );
-      case import_shared2.objectTypeSchema.Enum.sharedValue:
+      case objectTypeSchema.Enum.sharedValue:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -349,7 +1148,7 @@ var AbstractCrudService = class {
         id: possibleFolder.name
       };
       try {
-        return import_shared2.fileReferenceSchema.parse(folderReference);
+        return fileReferenceSchema.parse(folderReference);
       } catch (error) {
         return null;
       }
@@ -374,7 +1173,7 @@ var AbstractCrudService = class {
           extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
         };
         try {
-          return import_shared2.fileReferenceSchema.parse(fileReference);
+          return fileReferenceSchema.parse(fileReference);
         } catch (error) {
           return null;
         }
@@ -385,8 +1184,8 @@ var AbstractCrudService = class {
 };
 
 // src/service/GitService.ts
-var import_shared6 = require("@elek-io/shared");
 var import_dugite = require("dugite");
+var import_os3 = require("os");
 var import_p_queue = __toESM(require("p-queue"), 1);
 
 // src/error/GitError.ts
@@ -406,10 +1205,35 @@ var NoCurrentUserError = class extends Error {
 };
 
 // src/service/GitTagService.ts
-var import_shared3 = require("@elek-io/shared");
+var import_os2 = require("os");
+
+// src/schema/gitTagSchema.ts
+var import_zod10 = require("zod");
+var gitTagSchema = import_zod10.z.object({
+  id: uuidSchema,
+  message: import_zod10.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod10.z.number()
+});
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: gitRepositoryPathSchema,
+  hash: gitCommitSchema.shape.hash.optional()
+});
+var readGitTagSchema = import_zod10.z.object({
+  path: gitRepositoryPathSchema,
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = import_zod10.z.object({
+  path: gitRepositoryPathSchema
+});
+
+// src/service/GitTagService.ts
 var GitTagService = class extends AbstractCrudService {
   constructor(options, git) {
-    super(import_shared3.serviceTypeSchema.Enum.GitTag, options);
+    super(serviceTypeSchema.Enum.GitTag, options);
     this.git = git;
   }
   /**
@@ -418,8 +1242,8 @@ var GitTagService = class extends AbstractCrudService {
    * @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)();
+    createGitTagSchema.parse(props);
+    const id = uuid();
     let args = ["tag", "--annotate", id];
     if (props.hash) {
       args = [...args, props.hash];
@@ -432,22 +1256,20 @@ var GitTagService = class extends AbstractCrudService {
   /**
    * Returns a tag by ID
    *
-   * Internally uses list() with id as pattern.
+   * Internally uses list() but only returns the tag with matching ID.
    */
   async read(props) {
-    import_shared3.readGitTagSchema.parse(props);
-    const tags = await this.list({ path: props.path, filter: props.id });
-    if (tags.total === 0) {
+    readGitTagSchema.parse(props);
+    const tags = await this.list({ path: props.path });
+    const tag = tags.list.find((tag2) => {
+      return tag2.id === props.id;
+    });
+    if (!tag) {
       throw new GitError(
         `Provided tag with UUID "${props.id}" did not match any known tags`
       );
     }
-    if (tags.total > 1) {
-      throw new GitError(
-        `Provided tag with UUID "${props.id}" matched multiple known tags`
-      );
-    }
-    return tags.list[0];
+    return tag;
   }
   /**
    * Updating a git tag is not supported.
@@ -469,7 +1291,7 @@ var GitTagService = class extends AbstractCrudService {
    * @param id    UUID of the tag to delete
    */
   async delete(props) {
-    import_shared3.deleteGitTagSchema.parse(props);
+    deleteGitTagSchema.parse(props);
     const args = ["tag", "--delete", props.id];
     await this.git(props.path, args);
   }
@@ -482,7 +1304,7 @@ var GitTagService = class extends AbstractCrudService {
    * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
    */
   async list(props) {
-    import_shared3.listGitTagsSchema.parse(props);
+    listGitTagsSchema.parse(props);
     let args = ["tag", "--list"];
     args = [
       ...args,
@@ -490,8 +1312,8 @@ var GitTagService = class extends AbstractCrudService {
       "--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 noEmptyLinesArr = result.stdout.split(import_os2.EOL).filter((line) => {
+      return line.trim() !== "";
     });
     const lineObjArr = noEmptyLinesArr.map((line) => {
       const lineArray = line.split("|");
@@ -502,17 +1324,16 @@ var GitTagService = class extends AbstractCrudService {
           name: lineArray[2],
           email: lineArray[3]
         },
-        timestamp: typeof lineArray[4] === "string" ? parseInt(lineArray[4]) : void 0
+        timestamp: parseInt(lineArray[4])
       };
     });
     const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
-    return this.paginate(
-      gitTags,
-      props?.sort,
-      props?.filter,
-      props?.limit,
-      props?.offset
-    );
+    return {
+      total: gitTags.length,
+      limit: 0,
+      offset: 0,
+      list: gitTags
+    };
   }
   /**
    * Returns the total number of tags inside given repository
@@ -523,7 +1344,7 @@ var GitTagService = class extends AbstractCrudService {
    * @param path Path to the repository
    */
   async count(props) {
-    import_shared3.countGitTagsSchema.parse(props);
+    countGitTagsSchema.parse(props);
     const gitTags = await this.list({ path: props.path });
     return gitTags.total;
   }
@@ -533,19 +1354,33 @@ var GitTagService = class extends AbstractCrudService {
    * @param obj The object to check
    */
   isGitTag(obj) {
-    return import_shared3.gitTagSchema.safeParse(obj).success;
+    return gitTagSchema.safeParse(obj).success;
   }
 };
 
-// src/service/UserService.ts
-var import_shared5 = require("@elek-io/shared");
+// src/schema/userSchema.ts
+var import_zod11 = __toESM(require("zod"), 1);
+var UserTypeSchema = import_zod11.default.enum(["local", "cloud"]);
+var baseUserSchema = gitSignatureSchema.extend({
+  userType: UserTypeSchema,
+  language: supportedLanguageSchema
+});
+var localUserSchema = baseUserSchema.extend({
+  userType: import_zod11.default.literal(UserTypeSchema.Enum.local)
+});
+var cloudUserSchema = baseUserSchema.extend({
+  userType: import_zod11.default.literal(UserTypeSchema.Enum.cloud),
+  id: uuidSchema
+});
+var userFileSchema = import_zod11.default.union([localUserSchema, cloudUserSchema]);
+var userSchema = userFileSchema;
+var setUserSchema = userSchema;
 
 // 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);
+    super(serviceTypeSchema.Enum.JsonFile, options);
     this.cache = /* @__PURE__ */ new Map();
   }
   /**
@@ -626,7 +1461,7 @@ var UserService = class {
     try {
       return await this.jsonFileService.read(
         pathTo.userFile,
-        import_shared5.userFileSchema
+        userFileSchema
       );
     } catch (error) {
       return void 0;
@@ -638,14 +1473,14 @@ var UserService = class {
    * By doing so all git operations are done with the signature of this User
    */
   async set(props) {
-    import_shared5.setUserSchema.parse(props);
+    setUserSchema.parse(props);
     const userFilePath = pathTo.userFile;
     const userFile = {
       ...props
     };
-    if (userFile.userType === import_shared5.UserTypeSchema.Enum.cloud) {
+    if (userFile.userType === UserTypeSchema.Enum.cloud) {
     }
-    await this.jsonFileService.update(userFile, userFilePath, import_shared5.userFileSchema);
+    await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
     return userFile;
   }
 };
@@ -653,13 +1488,147 @@ var UserService = class {
 // src/service/GitService.ts
 var GitService2 = class {
   constructor(options, userService) {
-    this.version = void 0;
+    this.branches = {
+      /**
+       * List branches
+       *
+       * @see https://www.git-scm.com/docs/git-branch
+       *
+       * @param path  Path to the repository
+       */
+      list: async (path) => {
+        const args = ["branch", "--list", "--all"];
+        const result = await this.git(path, args);
+        const normalizedLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
+          return line.trim() !== "";
+        }).map((line) => {
+          return line.trim().replace("* ", "");
+        });
+        const local = [];
+        const remote = [];
+        normalizedLinesArr.forEach((line) => {
+          if (line.startsWith("remotes/")) {
+            remote.push(line.replace("remotes/", ""));
+          } else {
+            local.push(line);
+          }
+        });
+        return {
+          local,
+          remote
+        };
+      },
+      /**
+       * Returns the name of the current branch. In detached HEAD state, an empty string is returned.
+       *
+       * @see https://www.git-scm.com/docs/git-branch#Documentation/git-branch.txt---show-current
+       *
+       * @param path  Path to the repository
+       */
+      current: async (path) => {
+        const args = ["branch", "--show-current"];
+        const result = await this.git(path, args);
+        return result.stdout.trim();
+      },
+      /**
+       * Switch branches
+       *
+       * @see https://git-scm.com/docs/git-switch/
+       *
+       * @param path    Path to the repository
+       * @param branch  Name of the branch to switch to
+       * @param options Options specific to the switch operation
+       */
+      switch: async (path, branch, options) => {
+        await this.checkBranchOrTagName(path, branch);
+        let args = ["switch"];
+        if (options?.isNew === true) {
+          args = [...args, "--create", branch];
+        } else {
+          args = [...args, branch];
+        }
+        await this.git(path, args);
+      }
+    };
+    this.remotes = {
+      /**
+       * Returns a list of currently tracked remotes
+       *
+       * @see https://git-scm.com/docs/git-remote
+       *
+       * @param path  Path to the repository
+       */
+      list: async (path) => {
+        const args = ["remote"];
+        const result = await this.git(path, args);
+        const normalizedLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
+          return line.trim() !== "";
+        });
+        return normalizedLinesArr;
+      },
+      /**
+       * Returns true if the `origin` remote exists, otherwise false
+       *
+       * @param path  Path to the repository
+       */
+      hasOrigin: async (path) => {
+        const remotes = await this.remotes.list(path);
+        if (remotes.includes("origin")) {
+          return true;
+        }
+        return false;
+      },
+      /**
+       * Adds the `origin` remote with given URL
+       *
+       * Throws if `origin` remote is added already.
+       *
+       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emaddem
+       *
+       * @param path  Path to the repository
+       */
+      addOrigin: async (path, url) => {
+        const args = ["remote", "add", "origin", url];
+        await this.git(path, args);
+      },
+      /**
+       * Returns the current `origin` remote URL
+       *
+       * Throws if no `origin` remote is added yet.
+       *
+       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emget-urlem
+       *
+       * @param path  Path to the repository
+       */
+      getOriginUrl: async (path) => {
+        const args = ["remote", "get-url", "origin"];
+        const result = (await this.git(path, args)).stdout.trim();
+        return result.length === 0 ? null : result;
+      },
+      /**
+       * Sets the current `origin` remote URL
+       *
+       * Throws if no `origin` remote is added yet.
+       *
+       * @see https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-emset-urlem
+       *
+       * @param path  Path to the repository
+       */
+      setOriginUrl: async (path, url) => {
+        const args = ["remote", "set-url", "origin", url];
+        await this.git(path, args);
+      }
+    };
+    this.version = null;
+    this.gitPath = null;
     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;
+    this.updateVersion();
+    this.updateGitPath();
   }
   /**
    * CRUD methods to work with git tags
@@ -667,13 +1636,6 @@ var GitService2 = class {
   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
    *
@@ -714,7 +1676,7 @@ var GitService2 = class {
     if (options?.singleBranch === true) {
       args = [...args, "--single-branch"];
     }
-    await this.git(path, [...args, url, "."]);
+    await this.git("", [...args, url, path]);
     await this.setLocalConfig(path);
   }
   /**
@@ -729,25 +1691,6 @@ var GitService2 = class {
     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
    *
@@ -785,7 +1728,18 @@ var GitService2 = class {
   //   await this.git(path, args);
   // }
   /**
-   * Fetch from and integrate with another repository or a local branch
+   * Download objects and refs from remote `origin`
+   *
+   * @see https://www.git-scm.com/docs/git-fetch
+   *
+   * @param path Path to the repository
+   */
+  async fetch(path) {
+    const args = ["fetch"];
+    await this.git(path, args);
+  }
+  /**
+   * Fetch from and integrate (rebase or merge) with a local branch
    *
    * @see https://git-scm.com/docs/git-pull
    *
@@ -795,6 +1749,23 @@ var GitService2 = class {
     const args = ["pull"];
     await this.git(path, args);
   }
+  /**
+   * Update remote refs along with associated objects to remote `origin`
+   *
+   * @see https://git-scm.com/docs/git-push
+   *
+   * @param path Path to the repository
+   */
+  async push(path, options) {
+    let args = ["push", "origin"];
+    if (options?.all === true) {
+      args = [...args, "--all"];
+    }
+    if (options?.force === true) {
+      args = [...args, "--force"];
+    }
+    await this.git(path, args);
+  }
   /**
    * Record changes to the repository
    *
@@ -831,7 +1802,7 @@ var GitService2 = class {
     if (options?.between?.from) {
       args = [
         ...args,
-        `${options.between.from}...${options.between.to || "HEAD"}`
+        `${options.between.from}..${options.between.to || "HEAD"}`
       ];
     }
     if (options?.limit) {
@@ -841,8 +1812,8 @@ var GitService2 = class {
       ...args,
       "--format=%H|%s|%an|%ae|%at|%D"
     ]);
-    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
-      return line !== "";
+    const noEmptyLinesArr = result.stdout.split(import_os3.EOL).filter((line) => {
+      return line.trim() !== "";
     });
     const lineObjArr = noEmptyLinesArr.map((line) => {
       const lineArray = line.split("|");
@@ -860,10 +1831,9 @@ var GitService2 = class {
     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;
+    const tagName = refName.replace("tag: ", "").trim();
+    if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
+      return null;
     }
     return tagName;
   }
@@ -923,6 +1893,26 @@ var GitService2 = class {
       updated: meta[1]
     };
   }
+  /**
+   * Reads the currently used version of Git
+   *
+   * This can help debugging
+   */
+  async updateVersion() {
+    const result = await this.git("", ["--version"]);
+    this.version = result.stdout.replace("git version", "").trim();
+  }
+  /**
+   * Reads the path to the executable of Git that is used
+   *
+   * This can help debugging, since dugite is shipping their own executable
+   * but in some cases resolves another executable
+   * @see https://github.com/desktop/dugite/blob/main/lib/git-environment.ts
+   */
+  async updateGitPath() {
+    const result = await this.git("", ["--exec-path"]);
+    this.gitPath = result.stdout.trim();
+  }
   /**
    * A reference is used in Git to specify branches and tags.
    * This method checks if given name matches the required format
@@ -957,8 +1947,15 @@ var GitService2 = class {
     }
     const userNameArgs = ["config", "--local", "user.name", user.name];
     const userEmailArgs = ["config", "--local", "user.email", user.email];
+    const autoSetupRemoteArgs = [
+      "config",
+      "--local",
+      "push.autoSetupRemote",
+      "true"
+    ];
     await this.git(path, userNameArgs);
     await this.git(path, userEmailArgs);
+    await this.git(path, autoSetupRemoteArgs);
   }
   /**
    * Type guard for GitCommit
@@ -966,7 +1963,7 @@ var GitService2 = class {
    * @param obj The object to check
    */
   isGitCommit(obj) {
-    return import_shared6.gitCommitSchema.safeParse(obj).success;
+    return gitCommitSchema.safeParse(obj).success;
   }
   /**
    * Wraps the execution of any git command
@@ -976,14 +1973,29 @@ var GitService2 = class {
    * @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));
+    const result = await this.queue.add(
+      () => import_dugite.GitProcess.exec(args, path, {
+        env: {
+          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
+          // @see https://github.com/git-lfs/git-lfs/issues/5749
+          GIT_CLONE_PROTECTION_ACTIVE: "false"
+        }
+      })
+    );
     if (!result) {
       throw new GitError(
-        `Git (${this.version}) command "git ${args.join(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
           " "
         )}" failed to return a result`
       );
     }
+    if (result.exitCode !== 0) {
+      throw new GitError(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
+          " "
+        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
+      );
+    }
     return result;
   }
 };
@@ -991,7 +2003,7 @@ var GitService2 = class {
 // src/service/AssetService.ts
 var AssetService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService) {
-    super(import_shared7.serviceTypeSchema.Enum.Asset, options);
+    super(serviceTypeSchema.Enum.Asset, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -999,8 +2011,8 @@ var AssetService = class extends AbstractCrudService {
    * Creates a new Asset
    */
   async create(props) {
-    import_shared7.createAssetSchema.parse(props);
-    const id = (0, import_shared7.uuid)();
+    createAssetSchema.parse(props);
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const fileType = await this.getSupportedFileTypeOrThrow(props.filePath);
     const size = await this.getAssetSize(props.filePath);
@@ -1019,7 +2031,8 @@ var AssetService = class extends AbstractCrudService {
       ...props,
       objectType: "asset",
       id,
-      created: (0, import_shared7.currentTimestamp)(),
+      created: currentTimestamp(),
+      updated: null,
       extension: fileType.extension,
       mimeType: fileType.mimeType,
       size
@@ -1029,7 +2042,7 @@ var AssetService = class extends AbstractCrudService {
       await this.jsonFileService.create(
         assetFile,
         assetFilePath,
-        import_shared7.assetFileSchema
+        assetFileSchema
       );
     } catch (error) {
       await this.delete({ ...assetFile, projectId: props.projectId });
@@ -1043,10 +2056,10 @@ var AssetService = class extends AbstractCrudService {
    * Returns an Asset by ID and language
    */
   async read(props) {
-    import_shared7.readAssetSchema.parse(props);
+    readAssetSchema.parse(props);
     const assetFile = await this.jsonFileService.read(
       pathTo.assetFile(props.projectId, props.id, props.language),
-      import_shared7.assetFileSchema
+      assetFileSchema
     );
     return this.toAsset(props.projectId, assetFile);
   }
@@ -1056,7 +2069,7 @@ var AssetService = class extends AbstractCrudService {
    * Use the optional "newFilePath" prop to update the Asset itself
    */
   async update(props) {
-    import_shared7.updateAssetSchema.parse(props);
+    updateAssetSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const assetFilePath = pathTo.assetFile(
       props.projectId,
@@ -1067,7 +2080,7 @@ var AssetService = class extends AbstractCrudService {
     const assetFile = {
       ...prevAssetFile,
       ...props,
-      updated: (0, import_shared7.currentTimestamp)()
+      updated: currentTimestamp()
     };
     if (props.newFilePath) {
       const fileType = await this.getSupportedFileTypeOrThrow(
@@ -1095,7 +2108,7 @@ var AssetService = class extends AbstractCrudService {
     await this.jsonFileService.update(
       assetFile,
       assetFilePath,
-      import_shared7.assetFileSchema
+      assetFileSchema
     );
     await this.gitService.add(projectPath, [assetFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
@@ -1105,7 +2118,7 @@ var AssetService = class extends AbstractCrudService {
    * Deletes given Asset
    */
   async delete(props) {
-    import_shared7.deleteAssetSchema.parse(props);
+    deleteAssetSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const assetFilePath = pathTo.assetFile(
       props.projectId,
@@ -1124,13 +2137,16 @@ var AssetService = class extends AbstractCrudService {
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
-    import_shared7.listAssetsSchema.parse(props);
+    listAssetsSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
     const assetReferences = await this.listReferences(
-      import_shared7.objectTypeSchema.Enum.asset,
+      objectTypeSchema.Enum.asset,
       props.projectId
     );
-    const list = await returnResolved(
-      assetReferences.map((assetReference) => {
+    const partialAssetReferences = assetReferences.slice(offset, limit);
+    const assets = await returnResolved(
+      partialAssetReferences.map((assetReference) => {
         if (!assetReference.language) {
           throw new RequiredParameterMissingError("language");
         }
@@ -1141,25 +2157,23 @@ var AssetService = class extends AbstractCrudService {
         });
       })
     );
-    const paginatedResult = this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
-    return paginatedResult;
+    return {
+      total: assetReferences.length,
+      limit,
+      offset,
+      list: assets
+    };
   }
   async count(props) {
-    import_shared7.countAssetsSchema.parse(props);
-    const count = (await this.listReferences(import_shared7.objectTypeSchema.Enum.asset, props.projectId)).length;
+    countAssetsSchema.parse(props);
+    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
     return count;
   }
   /**
    * Checks if given object is of type Asset
    */
   isAsset(obj) {
-    return import_shared7.assetSchema.safeParse(obj).success;
+    return assetSchema.safeParse(obj).success;
   }
   /**
    * Returns the size of an Asset in bytes
@@ -1200,14 +2214,14 @@ var AssetService = class extends AbstractCrudService {
       const fileBuffer = await import_fs_extra3.default.readFile(filePath);
       if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
         return {
-          extension: import_shared7.supportedAssetExtensionSchema.Enum.svg,
-          mimeType: import_shared7.supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
+          extension: supportedAssetExtensionSchema.Enum.svg,
+          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
         };
       }
     }
     const { fileTypeFromFile } = await import("file-type");
     const fileType = await fileTypeFromFile(filePath);
-    const result = import_shared7.supportedAssetTypeSchema.parse({
+    const result = supportedAssetTypeSchema.parse({
       extension: fileType?.ext,
       mimeType: fileType?.mime
     });
@@ -1216,11 +2230,10 @@ var AssetService = class extends AbstractCrudService {
 };
 
 // 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);
+    super(serviceTypeSchema.Enum.Collection, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -1228,29 +2241,27 @@ var CollectionService = class extends AbstractCrudService {
    * Creates a new Collection
    */
   async create(props) {
-    import_shared8.createCollectionSchema.parse(props);
-    const id = (0, import_shared8.uuid)();
+    createCollectionSchema.parse(props);
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const collectionPath = pathTo.collection(props.projectId, id);
-    const collectionFilePath = pathTo.collectionFile(
-      props.projectId,
-      id
-    );
+    const collectionFilePath = pathTo.collectionFile(props.projectId, id);
     const collectionFile = {
       ...props,
       objectType: "collection",
       id,
       slug: {
-        singular: (0, import_shared8.slug)(props.slug.singular),
-        plural: (0, import_shared8.slug)(props.slug.plural)
+        singular: slug(props.slug.singular),
+        plural: slug(props.slug.plural)
       },
-      created: (0, import_shared8.currentTimestamp)()
+      created: currentTimestamp(),
+      updated: null
     };
     await import_fs_extra4.default.ensureDir(collectionPath);
     await this.jsonFileService.create(
       collectionFile,
       collectionFilePath,
-      import_shared8.collectionFileSchema
+      collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
@@ -1260,10 +2271,10 @@ var CollectionService = class extends AbstractCrudService {
    * Returns a Collection by ID
    */
   async read(props) {
-    import_shared8.readCollectionSchema.parse(props);
+    readCollectionSchema.parse(props);
     const collection = await this.jsonFileService.read(
       pathTo.collectionFile(props.projectId, props.id),
-      import_shared8.collectionFileSchema
+      collectionFileSchema
     );
     return collection;
   }
@@ -1278,7 +2289,7 @@ var CollectionService = class extends AbstractCrudService {
    *                    before given update can be executed or void if the update was executed successfully
    */
   async update(props) {
-    import_shared8.updateCollectionSchema.parse(props);
+    updateCollectionSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const collectionFilePath = pathTo.collectionFile(
       props.projectId,
@@ -1288,12 +2299,12 @@ var CollectionService = class extends AbstractCrudService {
     const collectionFile = {
       ...prevCollectionFile,
       ...props,
-      updated: (0, import_shared8.currentTimestamp)()
+      updated: currentTimestamp()
     };
     await this.jsonFileService.update(
       collectionFile,
       collectionFilePath,
-      import_shared8.collectionFileSchema
+      collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
@@ -1305,42 +2316,44 @@ var CollectionService = class extends AbstractCrudService {
    * The Fields that Collection used are not deleted.
    */
   async delete(props) {
-    import_shared8.deleteCollectionSchema.parse(props);
+    deleteCollectionSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const collectionPath = pathTo.collection(
-      props.projectId,
-      props.id
-    );
+    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.objectTypeSchema.Enum.collection,
+    listCollectionsSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const collectionReferences = await this.listReferences(
+      objectTypeSchema.Enum.collection,
       props.projectId
     );
-    const list = await returnResolved(
-      references.map((reference) => {
+    const partialCollectionReferences = collectionReferences.slice(
+      offset,
+      limit
+    );
+    const collections = await returnResolved(
+      partialCollectionReferences.map((reference) => {
         return this.read({
           projectId: props.projectId,
           id: reference.id
         });
       })
     );
-    return this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
+    return {
+      total: collectionReferences.length,
+      limit,
+      offset,
+      list: collections
+    };
   }
   async count(props) {
-    import_shared8.countCollectionsSchema.parse(props);
+    countCollectionsSchema.parse(props);
     const count = (await this.listReferences(
-      import_shared8.objectTypeSchema.Enum.collection,
+      objectTypeSchema.Enum.collection,
       props.projectId
     )).length;
     return count;
@@ -1349,17 +2362,16 @@ var CollectionService = class extends AbstractCrudService {
    * Checks if given object is of type Collection
    */
   isCollection(obj) {
-    return import_shared8.collectionFileSchema.safeParse(obj).success;
+    return collectionFileSchema.safeParse(obj).success;
   }
 };
 
 // src/service/EntryService.ts
-var import_shared9 = require("@elek-io/shared");
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
 var EntryService = class extends AbstractCrudService {
   // private sharedValueService: SharedValueService;
   constructor(options, jsonFileService, gitService, collectionService, assetService) {
-    super(import_shared9.serviceTypeSchema.Enum.Entry, options);
+    super(serviceTypeSchema.Enum.Entry, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
@@ -1369,8 +2381,8 @@ var EntryService = class extends AbstractCrudService {
    * Creates a new Entry for given Collection
    */
   async create(props) {
-    import_shared9.createEntrySchema.parse(props);
-    const id = (0, import_shared9.uuid)();
+    createEntrySchema.parse(props);
+    const id = uuid();
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
@@ -1385,7 +2397,8 @@ var EntryService = class extends AbstractCrudService {
       objectType: "entry",
       id,
       values: props.values,
-      created: (0, import_shared9.currentTimestamp)()
+      created: currentTimestamp(),
+      updated: null
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
@@ -1400,7 +2413,7 @@ var EntryService = class extends AbstractCrudService {
     await this.jsonFileService.create(
       entryFile,
       entryFilePath,
-      import_shared9.entryFileSchema
+      entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
@@ -1410,10 +2423,10 @@ var EntryService = class extends AbstractCrudService {
    * Returns an Entry from given Collection by ID and language
    */
   async read(props) {
-    import_shared9.readEntrySchema.parse(props);
+    readEntrySchema.parse(props);
     const entryFile = await this.jsonFileService.read(
       pathTo.entryFile(props.projectId, props.collectionId, props.id),
-      import_shared9.entryFileSchema
+      entryFileSchema
     );
     return await this.toEntry({
       projectId: props.projectId,
@@ -1425,7 +2438,7 @@ var EntryService = class extends AbstractCrudService {
    * Updates an Entry of given Collection with new Values and shared Values
    */
   async update(props) {
-    import_shared9.updateEntrySchema.parse(props);
+    updateEntrySchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
@@ -1444,7 +2457,7 @@ var EntryService = class extends AbstractCrudService {
     const entryFile = {
       ...prevEntryFile,
       values: props.values,
-      updated: (0, import_shared9.currentTimestamp)()
+      updated: currentTimestamp()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
@@ -1459,7 +2472,7 @@ var EntryService = class extends AbstractCrudService {
     await this.jsonFileService.update(
       entryFile,
       entryFilePath,
-      import_shared9.entryFileSchema
+      entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
@@ -1469,7 +2482,7 @@ var EntryService = class extends AbstractCrudService {
    * Deletes given Entry from it's Collection
    */
   async delete(props) {
-    import_shared9.deleteEntrySchema.parse(props);
+    deleteEntrySchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
@@ -1481,14 +2494,17 @@ var EntryService = class extends AbstractCrudService {
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
-    import_shared9.listEntriesSchema.parse(props);
-    const references = await this.listReferences(
-      import_shared9.objectTypeSchema.Enum.entry,
+    listEntriesSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const entryReferences = await this.listReferences(
+      objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     );
-    const list = await returnResolved(
-      references.map((reference) => {
+    const partialEntryReferences = entryReferences.slice(offset, limit);
+    const entries = await returnResolved(
+      partialEntryReferences.map((reference) => {
         return this.read({
           projectId: props.projectId,
           collectionId: props.collectionId,
@@ -1496,18 +2512,17 @@ var EntryService = class extends AbstractCrudService {
         });
       })
     );
-    return this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
+    return {
+      total: entryReferences.length,
+      limit,
+      offset,
+      list: entries
+    };
   }
   async count(props) {
-    import_shared9.countEntriesSchema.parse(props);
+    countEntriesSchema.parse(props);
     return (await this.listReferences(
-      import_shared9.objectTypeSchema.Enum.entry,
+      objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -1516,7 +2531,7 @@ var EntryService = class extends AbstractCrudService {
    * Checks if given object is of type Entry
    */
   isEntry(obj) {
-    return import_shared9.entrySchema.safeParse(obj).success;
+    return entrySchema.safeParse(obj).success;
   }
   /**
    * Returns a Value definition by ID
@@ -1545,14 +2560,10 @@ var EntryService = class extends AbstractCrudService {
         valueDefinitions: props.valueDefinitions,
         id: value.definitionId
       });
-      const schema = (0, import_shared9.getValueContentSchemaFromDefinition)(definition);
+      const schema = getValueContentSchemaFromDefinition(definition);
       try {
-        if (value.valueType === "reference") {
-          schema.parse(value.content);
-        } else {
-          for (const [language, content] of Object.entries(value.content)) {
-            schema.parse(content);
-          }
+        for (const [language, content] of Object.entries(value.content)) {
+          schema.parse(content);
         }
       } catch (error) {
         console.log("Definition:", definition);
@@ -1580,17 +2591,18 @@ var EntryService = class extends AbstractCrudService {
   //   });
   // }
   async resolveValueContentReference(props) {
-    switch (props.valueContentReference.referenceObjectType) {
-      case import_shared9.objectTypeSchema.Enum.asset:
-        return this.resolveValueContentReferenceToAsset({
+    switch (props.valueContentReference.objectType) {
+      case objectTypeSchema.Enum.asset:
+        return await this.assetService.read({
           projectId: props.projectId,
-          valueContentReferenceToAsset: props.valueContentReference
+          id: props.valueContentReference.id,
+          language: props.valueContentReference.language
         });
-      case import_shared9.objectTypeSchema.Enum.entry:
-        return this.resolveValueContentReferenceToEntry({
+      case objectTypeSchema.Enum.entry:
+        return await this.read({
           projectId: props.projectId,
           collectionId: props.collectionId,
-          valueContentReferenceToEntry: props.valueContentReference
+          id: props.valueContentReference.id
         });
       default:
         throw new Error(
@@ -1599,86 +2611,61 @@ var EntryService = class extends AbstractCrudService {
         );
     }
   }
-  async resolveValueContentReferenceToAsset(props) {
-    const resolvedReferences = await Promise.all(
-      props.valueContentReferenceToAsset.references.map(async (reference) => {
-        const resolvedAsset = await this.assetService.read({
-          projectId: props.projectId,
-          id: reference.id,
-          language: reference.language
-        });
-        return resolvedAsset;
-      })
-    );
-    return {
-      ...props.valueContentReferenceToAsset,
-      references: resolvedReferences
-    };
-  }
-  async resolveValueContentReferenceToEntry(props) {
-    const resolvedReferences = await Promise.all(
-      props.valueContentReferenceToEntry.references.map(async (reference) => {
-        const resolvedEntry = await this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: reference.id
-        });
-        return resolvedEntry;
-      })
-    );
-    return {
-      ...props.valueContentReferenceToEntry,
-      references: resolvedReferences
-    };
+  async resolveValueContentReferences(props) {
+    let resolvedContent = {};
+    for (const language in props.valueReference.content) {
+      const referencesOfLanguage = props.valueReference.content[language];
+      if (!referencesOfLanguage) {
+        throw new Error(
+          `Trying to access content references by language "${language}" failed`
+        );
+      }
+      const resolvedReferencesOfLanguage = await Promise.all(
+        referencesOfLanguage.map(async (reference) => {
+          return await this.resolveValueContentReference({
+            projectId: props.projectId,
+            collectionId: props.collectionId,
+            valueContentReference: reference
+          });
+        })
+      );
+      resolvedContent = {
+        ...resolvedContent,
+        [language]: resolvedReferencesOfLanguage
+      };
+    }
+    return resolvedContent;
   }
-  // private async resolveValueContentReferenceToSharedValue(props: {
-  //   projectId: string;
-  //   valueContentReferenceToSharedValue: ValueContentReferenceToSharedValue;
-  // }): Promise<ResolvedValueContentReferenceToSharedValue> {
-  //   const resolvedSharedValue = await this.sharedValueService.read({
-  //     projectId: props.projectId,
-  //     id: props.valueContentReferenceToSharedValue.references.id,
-  //     language: props.valueContentReferenceToSharedValue.references.language,
-  //   });
-  //   return {
-  //     ...props.valueContentReferenceToSharedValue,
-  //     references: {
-  //       ...props.valueContentReferenceToSharedValue.references,
-  //       resolved: resolvedSharedValue,
-  //     },
-  //   };
-  // }
   /**
    * Creates an Entry from given EntryFile by resolving it's Values
    */
   async toEntry(props) {
-    const entry = {
+    return {
       ...props.entryFile,
+      // @ts-ignore @todo fixme - I have no idea why this happens. The types seem to be compatible to me and they work
       values: await Promise.all(
         props.entryFile.values.map(async (value) => {
-          if (value.valueType === import_shared9.ValueTypeSchema.Enum.reference) {
-            const resolvedValueContentReference = await this.resolveValueContentReference({
+          if (value.valueType === ValueTypeSchema.Enum.reference) {
+            const resolvedContentReferences = await this.resolveValueContentReferences({
               projectId: props.projectId,
               collectionId: props.collectionId,
-              valueContentReference: value.content
+              valueReference: value
             });
             return {
               ...value,
-              content: resolvedValueContentReference
+              content: resolvedContentReferences
             };
           }
           return value;
         })
       )
     };
-    return entry;
   }
 };
 
 // src/service/ProjectService.ts
-var import_shared11 = require("@elek-io/shared");
 var import_fs_extra6 = __toESM(require("fs-extra"), 1);
-var import_os2 = __toESM(require("os"), 1);
+var import_os4 = __toESM(require("os"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_semver = __toESM(require("semver"), 1);
 
@@ -1690,81 +2677,52 @@ var ProjectUpgradeError = class extends Error {
   }
 };
 
-// src/service/SearchService.ts
-var import_shared10 = require("@elek-io/shared");
-var SearchService = class extends AbstractCrudService {
-  constructor(options, assetService, collectionService) {
-    super(import_shared10.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, objectType) {
-    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.objectType,
-          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) {
-    super(import_shared11.serviceTypeSchema.Enum.Project, options);
+  constructor(options, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
+    super(serviceTypeSchema.Enum.Project, options);
+    this.branches = {
+      list: async (props) => {
+        listBranchesProjectSchema.parse(props);
+        const projectPath = pathTo.project(props.id);
+        await this.gitService.fetch(projectPath);
+        return await this.gitService.branches.list(projectPath);
+      },
+      current: async (props) => {
+        currentBranchProjectSchema.parse(props);
+        const projectPath = pathTo.project(props.id);
+        return await this.gitService.branches.current(projectPath);
+      },
+      switch: async (props) => {
+        switchBranchProjectSchema.parse(props);
+        const projectPath = pathTo.project(props.id);
+        return await this.gitService.branches.switch(
+          projectPath,
+          props.branch,
+          props.options
+        );
+      }
+    };
+    this.remotes = {
+      getOriginUrl: async (props) => {
+        getRemoteOriginUrlProjectSchema.parse(props);
+        const projectPath = pathTo.project(props.id);
+        return await this.gitService.remotes.getOriginUrl(projectPath);
+      },
+      setOriginUrl: async (props) => {
+        setRemoteOriginUrlProjectSchema.parse(props);
+        const projectPath = pathTo.project(props.id);
+        const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+        if (!hasOrigin) {
+          await this.gitService.remotes.addOrigin(projectPath, props.url);
+        } else {
+          await this.gitService.remotes.setOriginUrl(projectPath, props.url);
+        }
+      }
+    };
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
-    this.searchService = searchService;
     this.assetService = assetService;
     this.collectionService = collectionService;
     this.entryService = entryService;
@@ -1773,12 +2731,12 @@ var ProjectService = class extends AbstractCrudService {
    * Creates a new Project
    */
   async create(props) {
-    import_shared11.createProjectSchema.parse(props);
+    createProjectSchema.parse(props);
     const user = await this.userService.get();
     if (!user) {
       throw new NoCurrentUserError();
     }
-    const id = (0, import_shared11.uuid)();
+    const id = uuid();
     const defaultSettings = {
       language: {
         default: user.language,
@@ -1791,7 +2749,8 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: (0, import_shared11.currentTimestamp)(),
+      created: currentTimestamp(),
+      updated: null,
       coreVersion: this.options.version,
       // @todo should be read from package.json to avoid duplicates
       status: "todo",
@@ -1806,50 +2765,83 @@ var ProjectService = class extends AbstractCrudService {
       await this.jsonFileService.create(
         projectFile,
         pathTo.projectFile(id),
-        import_shared11.projectFileSchema
+        projectFileSchema
       );
       await this.gitService.add(projectPath, ["."]);
       await this.gitService.commit(
         projectPath,
-        `${import_shared11.gitCommitIconSchema.enum.INIT} Created this new elek.io project`
+        `${gitCommitIconSchema.enum.INIT} Created this new elek.io project`
       );
-      await this.gitService.switch(projectPath, "stage", { isNew: true });
+      await this.gitService.branches.switch(projectPath, "stage", {
+        isNew: true
+      });
     } catch (error) {
       await this.delete({
         id
       });
       throw error;
     }
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
+  }
+  /**
+   * Clones a Project by URL
+   */
+  async clone(props) {
+    cloneProjectSchema.parse(props);
+    const tmpId = uuid();
+    const tmpProjectPath = import_path2.default.join(pathTo.tmp, tmpId);
+    await this.gitService.clone(props.url, tmpProjectPath);
+    const projectFile = await this.jsonFileService.read(
+      import_path2.default.join(tmpProjectPath, "project.json"),
+      projectFileSchema
+    );
+    const projectPath = pathTo.project(projectFile.id);
+    const alreadyExists = await import_fs_extra6.default.pathExists(projectPath);
+    if (alreadyExists) {
+      throw new Error(
+        `Tried to clone Project "${projectFile.id}" from "${props.url}" - but the Project already exists locally`
+      );
+    }
+    await import_fs_extra6.default.copy(tmpProjectPath, projectPath);
+    await import_fs_extra6.default.remove(tmpProjectPath);
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Returns a Project by ID
    */
   async read(props) {
-    import_shared11.readProjectSchema.parse(props);
+    readProjectSchema.parse(props);
     const projectFile = await this.jsonFileService.read(
       pathTo.projectFile(props.id),
-      import_shared11.projectFileSchema
+      projectFileSchema
     );
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Updates given Project
    */
   async update(props) {
-    import_shared11.updateProjectSchema.parse(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: (0, import_shared11.currentTimestamp)()
+      updated: currentTimestamp()
     };
-    await this.jsonFileService.update(projectFile, filePath, import_shared11.projectFileSchema);
+    await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
-    return projectFile;
+    return await this.toProject({
+      projectFile
+    });
   }
   /**
    * Upgrades given Project to the latest version of this client
@@ -1859,7 +2851,7 @@ var ProjectService = class extends AbstractCrudService {
    * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
    */
   async upgrade(props) {
-    import_shared11.upgradeProjectSchema.parse(props);
+    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)) {
@@ -1917,6 +2909,39 @@ var ProjectService = class extends AbstractCrudService {
       }
     }
   }
+  /**
+   * Returns the differences of the given Projects current branch
+   * between the local and remote `origin` (commits ahead & behind)
+   *
+   * - `behind` contains a list of commits on the current branch that are available on the remote `origin` but not yet locally
+   * - `ahead` contains a list of commits on the current branch that are available locally but not yet on the remote `origin`
+   */
+  async getChanges(props) {
+    getChangesProjectSchema.parse(props);
+    const projectPath = pathTo.project(props.id);
+    const currentBranch = await this.gitService.branches.current(projectPath);
+    await this.gitService.fetch(projectPath);
+    const behind = await this.gitService.log(projectPath, {
+      between: { from: currentBranch, to: `origin/${currentBranch}` }
+    });
+    const ahead = await this.gitService.log(projectPath, {
+      between: { from: `origin/${currentBranch}`, to: currentBranch }
+    });
+    return {
+      behind,
+      ahead
+    };
+  }
+  /**
+   * Pulls remote changes of `origin` down to the local repository
+   * and then pushes local commits to the upstream branch
+   */
+  async synchronize(props) {
+    synchronizeProjectSchema.parse(props);
+    const projectPath = pathTo.project(props.id);
+    await this.gitService.pull(projectPath);
+    await this.gitService.push(projectPath);
+  }
   /**
    * Deletes given Project
    *
@@ -1925,45 +2950,39 @@ var ProjectService = class extends AbstractCrudService {
    * Or changes that are not pushed to a remote yet, will be lost too.
    */
   async delete(props) {
-    import_shared11.deleteProjectSchema.parse(props);
+    deleteProjectSchema.parse(props);
     await import_fs_extra6.default.remove(pathTo.project(props.id));
   }
   async list(props) {
     if (props) {
-      import_shared11.listProjectsSchema.parse(props);
+      listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(import_shared11.objectTypeSchema.Enum.project);
-    const list = await returnResolved(
-      references.map((reference) => {
+    const offset = props?.offset || 0;
+    const limit = props?.limit || 15;
+    const projectReferences = await this.listReferences(
+      objectTypeSchema.Enum.project
+    );
+    const partialProjectReferences = projectReferences.slice(offset, limit);
+    const projects = await returnResolved(
+      partialProjectReferences.map((reference) => {
         return this.read({ id: reference.id });
       })
     );
-    return this.paginate(
-      list,
-      props?.sort,
-      props?.filter,
-      props?.limit,
-      props?.offset
-    );
+    return {
+      total: projectReferences.length,
+      limit,
+      offset,
+      list: projects
+    };
   }
   async count() {
-    return (await this.listReferences(import_shared11.objectTypeSchema.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);
+    return (await this.listReferences(objectTypeSchema.Enum.project)).length;
   }
   /**
    * Checks if given object is of type Project
    */
   isProject(obj) {
-    return import_shared11.projectFileSchema.safeParse(obj).success;
+    return projectFileSchema.safeParse(obj).success;
   }
   /**
    * Exports given Project to JSON
@@ -1995,13 +3014,21 @@ var ProjectService = class extends AbstractCrudService {
       collections: collectionExport
     };
   }
+  /**
+   * Creates a Project from given ProjectFile by adding git information
+   */
+  async toProject(props) {
+    return {
+      ...props.projectFile
+    };
+  }
   /**
    * 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_shared11.projectFolderSchema.Values);
+    const folders2 = Object.values(projectFolderSchema.Values);
     await Promise.all(
       folders2.map(async (folder) => {
         await import_fs_extra6.default.mkdirp(import_path2.default.join(path, folder));
@@ -2029,15 +3056,44 @@ var ProjectService = class extends AbstractCrudService {
       // projectFolderSchema.Enum.public + '/',
       // projectFolderSchema.Enum.logs + '/',
     ];
-    await import_fs_extra6.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os2.default.EOL));
+    await import_fs_extra6.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os4.default.EOL));
   }
 };
 
+// src/schema/coreSchema.ts
+var import_zod12 = require("zod");
+var elekIoCoreOptionsSchema = import_zod12.z.object({
+  /**
+   * The environment elek.io Core is currently running in
+   */
+  environment: environmentSchema,
+  /**
+   * The current version of elek.io Core
+   */
+  version: versionSchema,
+  file: import_zod12.z.object({
+    json: import_zod12.z.object({
+      /**
+       * If set, adds indentation with spaces (number) or escape character (string)
+       * and line break characters to saved JSON files on disk, to make them easier to read.
+       * Defaults to 2 spaces of indentation.
+       */
+      indentation: import_zod12.z.union([import_zod12.z.number(), import_zod12.z.string()])
+    })
+  })
+});
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
+  version: true
+}).partial({
+  environment: true,
+  file: true
+}).optional();
+
 // src/index.ts
 var ElekIoCore = class {
   // private readonly sharedValueService: SharedValueService;
   constructor(props) {
-    const parsedProps = import_shared12.constructorElekIoCoreSchema.parse(props);
+    const parsedProps = constructorElekIoCoreSchema.parse(props);
     const defaults = {
       environment: "production",
       version: "0.0.0",
@@ -2069,17 +3125,11 @@ var ElekIoCore = class {
       this.assetService
       // this.sharedValueService
     );
-    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
@@ -2103,7 +3153,13 @@ var ElekIoCore = class {
     return util_exports;
   }
   /**
-   *
+   * Exposes git functions
+   */
+  get git() {
+    return this.gitService;
+  }
+  /**
+   * Getter and setter methods for the User currently working with Core
    */
   get user() {
     return this.userService;