@elek-io/core 0.9.1 → 0.11.0

package/dist/node/index.node.js

@@ -7,12 +7,14 @@ var __export = (target, all) => {
 // src/index.node.ts
 import Fs7 from "fs-extra";
 
+// package.json
+var version = "0.11.0";
+
 // src/schema/assetSchema.ts
-import z3 from "zod";
+import z4 from "zod";
 
 // src/schema/baseSchema.ts
 import z from "zod";
-var environmentSchema = z.enum(["production", "development", "test"]);
 var supportedLanguageSchema = z.enum([
   /**
    * Bulgarian
@@ -67,39 +69,6 @@ var supportedLanguageSchema = z.enum([
   // (Simplified) Chinese
 ]);
 var supportedIconSchema = z.enum(["home", "plus", "foobar"]);
-var supportedAssetMimeTypeSchema = z.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 = z.enum([
-  "avif",
-  "gif",
-  "jpg",
-  "jpeg",
-  "png",
-  "svg",
-  "webp",
-  "pdf",
-  "zip",
-  "mp4",
-  "webm",
-  "flac",
-  "json"
-]);
-var supportedAssetTypeSchema = z.object({
-  extension: supportedAssetExtensionSchema,
-  mimeType: supportedAssetMimeTypeSchema
-});
 var objectTypeSchema = z.enum([
   "project",
   "asset",
@@ -108,6 +77,7 @@ var objectTypeSchema = z.enum([
   "value",
   "sharedValue"
 ]);
+var logLevelSchema = z.enum(["error", "warn", "info", "debug"]);
 var versionSchema = z.string();
 var uuidSchema = z.string().uuid("shared.invalidUuid");
 var translatableStringSchema = z.record(
@@ -129,6 +99,10 @@ function translatableArrayOf(schema) {
 // src/schema/fileSchema.ts
 import z2 from "zod";
 var baseFileSchema = z2.object({
+  /**
+   * The object type of the file
+   */
+  objectType: objectTypeSchema.readonly(),
   /**
    * The ID of the file
    *
@@ -144,40 +118,150 @@ var baseFileSchema = z2.object({
    */
   updated: z2.string().datetime().nullable()
 });
-var baseFileWithLanguageSchema = baseFileSchema.extend({
+var fileReferenceSchema = z2.object({
+  id: uuidSchema,
+  extension: z2.string().optional()
+});
+
+// src/schema/gitSchema.ts
+import { z as z3 } from "zod";
+var gitSignatureSchema = z3.object({
+  name: z3.string(),
+  email: z3.string()
+});
+var gitMessageSchema = z3.object({
+  method: z3.enum(["create", "update", "delete", "upgrade"]),
+  reference: z3.object({
+    objectType: objectTypeSchema,
+    /**
+     * ID of the objectType
+     */
+    id: uuidSchema,
+    /**
+     * Only present if the objectType is of "entry"
+     */
+    collectionId: uuidSchema.optional()
+  })
+});
+var gitTagSchema = z3.object({
+  id: uuidSchema,
+  message: z3.string(),
+  author: gitSignatureSchema,
+  datetime: z3.string().datetime()
+});
+var gitCommitSchema = z3.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: z3.string(),
+  message: gitMessageSchema,
+  author: gitSignatureSchema,
+  datetime: z3.string().datetime(),
+  tag: gitTagSchema.nullable()
+});
+var gitInitOptionsSchema = z3.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: z3.string()
+});
+var gitCloneOptionsSchema = z3.object({
   /**
-   * The language of the file
+   * 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: z3.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: z3.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: z3.string(),
+  /**
+   * Make a bare Git repository. That is, instead of creating <directory> and placing the administrative files in <directory>`/.git`, make the <directory> itself the $GIT_DIR.
+   * Used primarily to copy an existing local repository to a server, where you want to set up the repository as a central point to work with others.
    *
-   * 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.
+   * The destination path for the cloned repository should end with a .git by convention.
    *
-   * @todo Maybe remove the above restriction by implementing logic to handle changing the files language inside all services
+   * @see https://git-scm.com/book/en/v2/Git-on-the-Server-Getting-Git-on-a-Server
    */
-  language: supportedLanguageSchema.readonly()
+  bare: z3.boolean()
 });
-var fileReferenceSchema = z2.object({
-  id: uuidSchema,
-  language: supportedLanguageSchema.optional(),
-  extension: supportedAssetExtensionSchema.optional()
+var gitMergeOptionsSchema = z3.object({
+  squash: z3.boolean()
+});
+var gitSwitchOptionsSchema = z3.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: z3.boolean().optional()
+});
+var gitLogOptionsSchema = z3.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: z3.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: z3.object({
+    /**
+     * From the oldest commit
+     */
+    from: z3.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: z3.string().optional()
+  }),
+  /**
+   * Only shows commits of given file
+   */
+  filePath: z3.string().optional()
+});
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: z3.string(),
+  hash: z3.string().optional()
+});
+var readGitTagSchema = z3.object({
+  path: z3.string(),
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = z3.object({
+  path: z3.string()
 });
 
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
-  objectType: z3.literal(objectTypeSchema.Enum.asset).readonly(),
-  name: z3.string(),
-  description: z3.string(),
-  extension: supportedAssetExtensionSchema.readonly(),
-  mimeType: supportedAssetMimeTypeSchema.readonly(),
+  objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: z4.string(),
+  description: z4.string(),
+  extension: z4.string().readonly(),
+  mimeType: z4.string().readonly(),
   /**
    * Total size in bytes
    */
-  size: z3.number().readonly()
+  size: z4.number().readonly()
 });
 var assetSchema = assetFileSchema.extend({
   /**
    * Absolute path on this filesystem
    */
-  absolutePath: z3.string().readonly()
+  absolutePath: z4.string().readonly(),
+  /**
+   * Commit history of this Asset
+   */
+  history: z4.array(gitCommitSchema)
 });
 var assetExportSchema = assetSchema.extend({});
 var createAssetSchema = assetFileSchema.pick({
@@ -188,12 +272,20 @@ var createAssetSchema = assetFileSchema.pick({
   /**
    * Path of the file to add as a new Asset
    */
-  filePath: z3.string().readonly()
+  filePath: z4.string().readonly()
 });
 var readAssetSchema = assetFileSchema.pick({
   id: true
 }).extend({
-  projectId: uuidSchema.readonly()
+  projectId: uuidSchema.readonly(),
+  commitHash: z4.string().optional().readonly()
+});
+var saveAssetSchema = assetFileSchema.pick({
+  id: true
+}).extend({
+  projectId: uuidSchema.readonly(),
+  filePath: z4.string().readonly(),
+  commitHash: z4.string().optional().readonly()
 });
 var updateAssetSchema = assetFileSchema.pick({
   id: true,
@@ -204,7 +296,7 @@ var updateAssetSchema = assetFileSchema.pick({
   /**
    * Path of the new file to update the Asset with
    */
-  newFilePath: z3.string().readonly().optional()
+  newFilePath: z4.string().readonly().optional()
 });
 var deleteAssetSchema = assetFileSchema.pick({
   id: true,
@@ -212,92 +304,93 @@ var deleteAssetSchema = assetFileSchema.pick({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var countAssetsSchema = z3.object({ projectId: uuidSchema.readonly() });
+var countAssetsSchema = z4.object({ projectId: uuidSchema.readonly() });
 
 // src/schema/collectionSchema.ts
-import z7 from "zod";
+import z8 from "zod";
 
 // src/schema/entrySchema.ts
-import z5 from "zod";
+import z6 from "zod";
 
 // src/schema/valueSchema.ts
-import z4 from "zod";
-var ValueTypeSchema = z4.enum([
+import z5 from "zod";
+var ValueTypeSchema = z5.enum([
   "string",
   "number",
   "boolean",
   "reference"
 ]);
-var valueContentReferenceBase = z4.object({
+var valueContentReferenceBase = z5.object({
   id: uuidSchema
 });
-var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
-  language: supportedLanguageSchema
-});
 var valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.asset)
+  objectType: z5.literal(objectTypeSchema.Enum.asset)
 });
 var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.collection)
+  objectType: z5.literal(objectTypeSchema.Enum.collection)
 });
 var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.entry)
+  objectType: z5.literal(objectTypeSchema.Enum.entry)
 });
-var valueContentReferenceSchema = z4.union([
+var valueContentReferenceSchema = z5.union([
   valueContentReferenceToAssetSchema,
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema
   // valueContentReferenceToSharedValueSchema,
 ]);
-var resolvedValueContentReferenceSchema = z4.union([
+var resolvedValueContentReferenceSchema = z5.union([
   assetSchema,
-  z4.lazy(() => entrySchema)
+  z5.lazy(() => entrySchema)
   // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
   // resolvedValueContentReferenceToSharedValueSchema,
 ]);
-var directValueBaseSchema = z4.object({
-  objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
+var directValueBaseSchema = z5.object({
+  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.string).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.string).readonly(),
   content: translatableStringSchema
 });
 var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.number).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.number).readonly(),
   content: translatableNumberSchema
 });
 var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: z4.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.boolean).readonly(),
   content: translatableBooleanSchema
 });
-var directValueSchema = z4.union([
+var directValueSchema = z5.union([
   directStringValueSchema,
   directNumberValueSchema,
   directBooleanValueSchema
 ]);
-var referencedValueSchema = z4.object({
-  objectType: z4.literal(objectTypeSchema.Enum.value).readonly(),
+var referencedValueSchema = z5.object({
+  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly(),
-  valueType: z4.literal(ValueTypeSchema.Enum.reference).readonly(),
+  valueType: z5.literal(ValueTypeSchema.Enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
-var valueSchema = z4.union([directValueSchema, referencedValueSchema]);
+var valueSchema = z5.union([directValueSchema, referencedValueSchema]);
 var resolvedReferencedValueSchema = referencedValueSchema.extend({
   content: translatableArrayOf(resolvedValueContentReferenceSchema)
 });
-var resolvedValueSchema = z4.union([
+var resolvedValueSchema = z5.union([
   directValueSchema,
   resolvedReferencedValueSchema
 ]);
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.entry).readonly(),
-  values: z5.array(valueSchema)
+  objectType: z6.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: z6.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
-  values: z5.array(z5.lazy(() => resolvedValueSchema))
+  values: z6.array(z6.lazy(() => resolvedValueSchema)),
+  /**
+   * Commit history of this Entry
+   */
+  history: z6.array(gitCommitSchema)
 });
 var entryExportSchema = entrySchema.extend({});
 var createEntrySchema = entryFileSchema.omit({
@@ -308,14 +401,15 @@ var createEntrySchema = entryFileSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly(),
-  values: z5.array(valueSchema)
+  values: z6.array(valueSchema)
 });
-var readEntrySchema = z5.object({
+var readEntrySchema = z6.object({
   id: uuidSchema.readonly(),
   projectId: uuidSchema.readonly(),
-  collectionId: uuidSchema.readonly()
+  collectionId: uuidSchema.readonly(),
+  commitHash: z6.string().optional().readonly()
 });
-var updateEntrySchema = entrySchema.omit({
+var updateEntrySchema = entryFileSchema.omit({
   objectType: true,
   created: true,
   updated: true
@@ -324,14 +418,14 @@ var updateEntrySchema = entrySchema.omit({
   collectionId: uuidSchema.readonly()
 });
 var deleteEntrySchema = readEntrySchema.extend({});
-var countEntriesSchema = z5.object({
+var countEntriesSchema = z6.object({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly()
 });
 
 // src/schema/fieldSchema.ts
-import { z as z6 } from "zod";
-var FieldTypeSchema = z6.enum([
+import { z as z7 } from "zod";
+var FieldTypeSchema = z7.enum([
   // String Values
   "text",
   "textarea",
@@ -353,67 +447,67 @@ var FieldTypeSchema = z6.enum([
   "entry"
   // 'sharedValue', // @todo
 ]);
-var FieldWidthSchema = z6.enum(["12", "6", "4", "3"]);
-var FieldDefinitionBaseSchema = z6.object({
+var FieldWidthSchema = z7.enum(["12", "6", "4", "3"]);
+var FieldDefinitionBaseSchema = z7.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
   description: translatableStringSchema,
-  isRequired: z6.boolean(),
-  isDisabled: z6.boolean(),
-  isUnique: z6.boolean(),
+  isRequired: z7.boolean(),
+  isDisabled: z7.boolean(),
+  isUnique: z7.boolean(),
   inputWidth: FieldWidthSchema
 });
 var StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z6.literal(ValueTypeSchema.Enum.string),
-    defaultValue: z6.string().nullable()
+    valueType: z7.literal(ValueTypeSchema.Enum.string),
+    defaultValue: z7.string().nullable()
   }
 );
 var textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.text),
-    min: z6.number().nullable(),
-    max: z6.number().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.text),
+    min: z7.number().nullable(),
+    max: z7.number().nullable()
   }
 );
 var textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.textarea),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.textarea),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
 var emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.email),
-  defaultValue: z6.string().email().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.email),
+  defaultValue: z7.string().email().nullable()
 });
 var urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.url),
-  defaultValue: z6.string().url().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.url),
+  defaultValue: z7.string().url().nullable()
 });
 var ipFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.ip),
-  defaultValue: z6.string().ip().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.ip),
+  defaultValue: z7.string().ip().nullable()
 });
 var dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.date),
-    defaultValue: z6.string().date().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.date),
+    defaultValue: z7.string().date().nullable()
   }
 );
 var timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z6.literal(FieldTypeSchema.Enum.time),
-    defaultValue: z6.string().time().nullable()
+    fieldType: z7.literal(FieldTypeSchema.Enum.time),
+    defaultValue: z7.string().time().nullable()
   }
 );
 var datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.datetime),
-  defaultValue: z6.string().datetime().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.datetime),
+  defaultValue: z7.string().datetime().nullable()
 });
 var telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.telephone)
+  fieldType: z7.literal(FieldTypeSchema.Enum.telephone)
   // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
 });
-var stringFieldDefinitionSchema = z6.union([
+var stringFieldDefinitionSchema = z7.union([
   textFieldDefinitionSchema,
   textareaFieldDefinitionSchema,
   emailFieldDefinitionSchema,
@@ -426,50 +520,49 @@ var stringFieldDefinitionSchema = z6.union([
 ]);
 var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z6.literal(ValueTypeSchema.Enum.number),
-    min: z6.number().nullable(),
-    max: z6.number().nullable(),
-    isUnique: z6.literal(false),
-    defaultValue: z6.number().nullable()
+    valueType: z7.literal(ValueTypeSchema.Enum.number),
+    min: z7.number().nullable(),
+    max: z7.number().nullable(),
+    isUnique: z7.literal(false),
+    defaultValue: z7.number().nullable()
   }
 );
 var numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.number)
+  fieldType: z7.literal(FieldTypeSchema.Enum.number)
 });
 var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.range),
+  fieldType: z7.literal(FieldTypeSchema.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: z6.literal(true),
-  min: z6.number(),
-  max: z6.number(),
-  defaultValue: z6.number()
+  isRequired: z7.literal(true),
+  min: z7.number(),
+  max: z7.number(),
+  defaultValue: z7.number()
 });
 var BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z6.literal(ValueTypeSchema.Enum.boolean),
+  valueType: z7.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: z6.literal(true),
-  defaultValue: z6.boolean(),
-  isUnique: z6.literal(false)
+  isRequired: z7.literal(true),
+  defaultValue: z7.boolean(),
+  isUnique: z7.literal(false)
 });
 var toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.toggle)
+  fieldType: z7.literal(FieldTypeSchema.Enum.toggle)
 });
 var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z6.literal(ValueTypeSchema.Enum.reference)
+  valueType: z7.literal(ValueTypeSchema.Enum.reference)
 });
 var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.asset),
-  allowedMimeTypes: z6.array(supportedAssetMimeTypeSchema).min(1),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.asset),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
 var entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z6.literal(FieldTypeSchema.Enum.entry),
-  ofCollections: z6.array(uuidSchema),
-  min: z6.number().nullable(),
-  max: z6.number().nullable()
+  fieldType: z7.literal(FieldTypeSchema.Enum.entry),
+  ofCollections: z7.array(uuidSchema),
+  min: z7.number().nullable(),
+  max: z7.number().nullable()
 });
-var fieldDefinitionSchema = z6.union([
+var fieldDefinitionSchema = z7.union([
   stringFieldDefinitionSchema,
   numberFieldDefinitionSchema,
   rangeFieldDefinitionSchema,
@@ -496,10 +589,10 @@ function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
   }
 }
 function getBooleanValueContentSchema() {
-  return z6.boolean();
+  return z7.boolean();
 }
 function getNumberValueContentSchema(definition) {
-  let schema = z6.number();
+  let schema = z7.number();
   if (definition.min) {
     schema = schema.min(definition.min);
   }
@@ -512,7 +605,7 @@ function getNumberValueContentSchema(definition) {
   return schema;
 }
 function getStringValueContentSchema(definition) {
-  let schema = z6.string().trim();
+  let schema = z7.string().trim();
   if ("min" in definition && definition.min) {
     schema = schema.min(definition.min);
   }
@@ -551,12 +644,12 @@ function getReferenceValueContentSchema(definition) {
   switch (definition.fieldType) {
     case FieldTypeSchema.Enum.asset:
       {
-        schema = z6.array(valueContentReferenceToAssetSchema);
+        schema = z7.array(valueContentReferenceToAssetSchema);
       }
       break;
     case FieldTypeSchema.Enum.entry:
       {
-        schema = z6.array(valueContentReferenceToEntrySchema);
+        schema = z7.array(valueContentReferenceToEntrySchema);
       }
       break;
   }
@@ -574,24 +667,29 @@ function getReferenceValueContentSchema(definition) {
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: z7.literal(objectTypeSchema.Enum.collection).readonly(),
-  name: z7.object({
+  objectType: z8.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: z8.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
   }),
-  slug: z7.object({
-    singular: z7.string(),
-    plural: z7.string()
+  slug: z8.object({
+    singular: z8.string(),
+    plural: z8.string()
   }),
   description: translatableStringSchema,
   icon: supportedIconSchema,
-  fieldDefinitions: z7.array(fieldDefinitionSchema)
+  fieldDefinitions: z8.array(fieldDefinitionSchema)
+});
+var collectionSchema = collectionFileSchema.extend({
+  /**
+   * Commit history of this Collection
+   */
+  history: z8.array(gitCommitSchema)
 });
-var collectionSchema = collectionFileSchema.extend({});
 var collectionExportSchema = collectionSchema.extend({
-  entries: z7.array(entryExportSchema)
+  entries: z8.array(entryExportSchema)
 });
-var createCollectionSchema = collectionSchema.omit({
+var createCollectionSchema = collectionFileSchema.omit({
   id: true,
   objectType: true,
   created: true,
@@ -599,9 +697,10 @@ var createCollectionSchema = collectionSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var readCollectionSchema = z7.object({
+var readCollectionSchema = z8.object({
   id: uuidSchema.readonly(),
-  projectId: uuidSchema.readonly()
+  projectId: uuidSchema.readonly(),
+  commitHash: z8.string().optional().readonly()
 });
 var updateCollectionSchema = collectionFileSchema.pick({
   id: true,
@@ -614,149 +713,45 @@ var updateCollectionSchema = collectionFileSchema.pick({
   projectId: uuidSchema.readonly()
 });
 var deleteCollectionSchema = readCollectionSchema.extend({});
-var countCollectionsSchema = z7.object({
+var countCollectionsSchema = z8.object({
   projectId: uuidSchema.readonly()
 });
 
 // src/schema/coreSchema.ts
-import { z as z8 } from "zod";
-var elekIoCoreOptionsSchema = z8.object({
-  /**
-   * The environment elek.io Core is currently running in
-   */
-  environment: environmentSchema,
-  /**
-   * The current version of elek.io Core
-   */
-  version: versionSchema,
-  file: z8.object({
-    json: z8.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: z8.union([z8.number(), z8.string()])
-    })
-  })
-});
-var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
-  version: true
-}).partial({
-  environment: true,
-  file: true
-}).optional();
-
-// src/schema/gitSchema.ts
 import { z as z9 } from "zod";
-var gitRepositoryPathSchema = z9.string();
-var gitSignatureSchema = z9.object({
-  name: z9.string(),
-  email: z9.string()
-});
-var gitCommitSchema = z9.object({
-  /**
-   * SHA-1 hash of the commit
-   */
-  hash: z9.string(),
-  message: z9.string(),
-  author: gitSignatureSchema,
-  datetime: z9.string().datetime(),
-  tag: z9.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 = z9.nativeEnum(GitCommitIconNative);
-var gitInitOptionsSchema = z9.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: z9.string()
-});
-var gitCloneOptionsSchema = z9.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: z9.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: z9.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: z9.string()
-});
-var gitSwitchOptionsSchema = z9.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: z9.boolean().optional()
-});
-var gitLogOptionsSchema = z9.object({
-  /**
-   * Limit the result to given number of commits
-   */
-  limit: z9.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: z9.object({
+var elekIoCoreOptionsSchema = z9.object({
+  log: z9.object({
     /**
-     * From the oldest commit
+     * The lowest level that should be logged
+     *
+     * @default 'info'
      */
-    from: z9.string(),
+    level: logLevelSchema
+  }),
+  file: z9.object({
     /**
-     * To the newest commit
+     * If set to true, caches files in memory to speed up access
      *
-     * Defaults to the current HEAD
+     * @default true
      */
-    to: z9.string().optional()
+    cache: z9.boolean()
   })
 });
-
-// src/schema/gitTagSchema.ts
-import { z as z10 } from "zod";
-var gitTagSchema = z10.object({
-  id: uuidSchema,
-  message: z10.string(),
-  author: gitSignatureSchema,
-  datetime: z10.string().datetime()
-});
-var createGitTagSchema = gitTagSchema.pick({
-  message: true
-}).extend({
-  path: gitRepositoryPathSchema,
-  hash: gitCommitSchema.shape.hash.optional()
-});
-var readGitTagSchema = z10.object({
-  path: gitRepositoryPathSchema,
-  id: uuidSchema.readonly()
-});
-var deleteGitTagSchema = readGitTagSchema.extend({});
-var countGitTagsSchema = z10.object({
-  path: gitRepositoryPathSchema
-});
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
+  log: true,
+  file: true
+}).optional();
 
 // src/schema/projectSchema.ts
-import { z as z11 } from "zod";
-var projectStatusSchema = z11.enum(["foo", "bar", "todo"]);
-var projectSettingsSchema = z11.object({
-  language: z11.object({
+import { z as z10 } from "zod";
+var projectStatusSchema = z10.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = z10.object({
+  language: z10.object({
     default: supportedLanguageSchema,
-    supported: z11.array(supportedLanguageSchema)
+    supported: z10.array(supportedLanguageSchema)
   })
 });
-var projectFolderSchema = z11.enum([
+var projectFolderSchema = z10.enum([
   "assets",
   "collections",
   "shared-values",
@@ -765,19 +760,36 @@ var projectFolderSchema = z11.enum([
   // 'public',
   // 'theme',
 ]);
+var projectBranchSchema = z10.enum(["production", "work"]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: z11.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: z10.literal(objectTypeSchema.Enum.project).readonly(),
   coreVersion: versionSchema,
-  name: z11.string().trim().min(1, "shared.projectNameRequired"),
-  description: z11.string().trim().min(1, "shared.projectDescriptionRequired"),
+  name: z10.string().trim().min(1, "shared.projectNameRequired"),
+  description: z10.string().trim().min(1, "shared.projectDescriptionRequired"),
   version: versionSchema,
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
-var projectSchema = projectFileSchema.extend({});
+var projectSchema = projectFileSchema.extend({
+  remoteOriginUrl: z10.string().nullable(),
+  /**
+   * Commit history of this Project
+   */
+  history: z10.array(gitCommitSchema),
+  /**
+   * Full commit history of this Project
+   * including all Assets, Collections, Entries and other files
+   */
+  fullHistory: z10.array(gitCommitSchema)
+});
+var outdatedProjectSchema = projectFileSchema.pick({
+  id: true,
+  name: true,
+  coreVersion: true
+});
 var projectExportSchema = projectSchema.extend({
-  assets: z11.array(assetExportSchema),
-  collections: z11.array(collectionExportSchema)
+  assets: z10.array(assetExportSchema),
+  collections: z10.array(collectionExportSchema)
 });
 var createProjectSchema = projectSchema.pick({
   name: true,
@@ -787,8 +799,9 @@ var createProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var readProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+var readProjectSchema = z10.object({
+  id: uuidSchema.readonly(),
+  commitHash: z10.string().optional().readonly()
 });
 var updateProjectSchema = projectSchema.pick({
   id: true,
@@ -800,11 +813,17 @@ var updateProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var upgradeProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+var upgradeProjectSchema = z10.object({
+  id: uuidSchema.readonly(),
+  /**
+   * Force the upgrade even if the Project is up-to-date
+   */
+  force: z10.boolean().optional()
+});
+var deleteProjectSchema = readProjectSchema.extend({
+  force: z10.boolean().optional()
 });
-var deleteProjectSchema = readProjectSchema.extend({});
-var projectUpgradeSchema = z11.object({
+var projectUpgradeSchema = z10.object({
   /**
    * The Core version the Project will be upgraded to
    */
@@ -812,45 +831,45 @@ var projectUpgradeSchema = z11.object({
   /**
    * Function that will be executed in the process of upgrading a Project
    */
-  run: z11.function().args(projectFileSchema).returns(z11.promise(z11.void()))
+  run: z10.function().args(projectFileSchema).returns(z10.promise(z10.void()))
 });
-var cloneProjectSchema = z11.object({
-  url: z11.string()
+var cloneProjectSchema = z10.object({
+  url: z10.string()
 });
-var listBranchesProjectSchema = z11.object({
+var listBranchesProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var currentBranchProjectSchema = z11.object({
+var currentBranchProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var switchBranchProjectSchema = z11.object({
+var switchBranchProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  branch: z11.string(),
+  branch: z10.string(),
   options: gitSwitchOptionsSchema.optional()
 });
-var getRemoteOriginUrlProjectSchema = z11.object({
+var getRemoteOriginUrlProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var setRemoteOriginUrlProjectSchema = z11.object({
+var setRemoteOriginUrlProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  url: z11.string()
+  url: z10.string()
 });
-var getChangesProjectSchema = z11.object({
+var getChangesProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var synchronizeProjectSchema = z11.object({
+var synchronizeProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var searchProjectSchema = z11.object({
+var searchProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  query: z11.string(),
+  query: z10.string(),
   language: supportedLanguageSchema,
-  type: z11.array(objectTypeSchema).optional()
+  type: z10.array(objectTypeSchema).optional()
 });
 
 // src/schema/serviceSchema.ts
-import { z as z12 } from "zod";
-var serviceTypeSchema = z12.enum([
+import { z as z11 } from "zod";
+var serviceTypeSchema = z11.enum([
   "Git",
   "GitTag",
   "User",
@@ -862,10 +881,10 @@ var serviceTypeSchema = z12.enum([
   "Entry",
   "Value"
 ]);
-var listSchema = z12.object({
+var listSchema = z11.object({
   projectId: uuidSchema,
-  limit: z12.number().optional(),
-  offset: z12.number().optional()
+  limit: z11.number().optional(),
+  offset: z11.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -875,33 +894,33 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z12.object({
-  path: gitRepositoryPathSchema
+var listGitTagsSchema = z11.object({
+  path: z11.string()
 });
 
 // src/schema/userSchema.ts
-import z13 from "zod";
-var UserTypeSchema = z13.enum(["local", "cloud"]);
+import z12 from "zod";
+var UserTypeSchema = z12.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
-  window: z13.object({
-    width: z13.number(),
-    height: z13.number(),
-    position: z13.object({
-      x: z13.number(),
-      y: z13.number()
+  window: z12.object({
+    width: z12.number(),
+    height: z12.number(),
+    position: z12.object({
+      x: z12.number(),
+      y: z12.number()
     })
   }).nullable()
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z13.literal(UserTypeSchema.Enum.local)
+  userType: z12.literal(UserTypeSchema.Enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z13.literal(UserTypeSchema.Enum.cloud),
+  userType: z12.literal(UserTypeSchema.Enum.cloud),
   id: uuidSchema
 });
-var userFileSchema = z13.union([localUserSchema, cloudUserSchema]);
+var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
@@ -940,17 +959,14 @@ var RequiredParameterMissingError = class extends Error {
 // src/util/node.ts
 var node_exports = {};
 __export(node_exports, {
-  assignDefaultIfMissing: () => assignDefaultIfMissing,
   files: () => files,
   folders: () => folders,
   isNoError: () => isNoError,
   notEmpty: () => notEmpty,
   pathTo: () => pathTo,
   returnResolved: () => returnResolved,
-  spawnChildProcess: () => spawnChildProcess,
   workingDirectory: () => workingDirectory
 });
-import { spawn } from "child_process";
 import Fs from "fs-extra";
 import Os from "os";
 import Path from "path";
@@ -958,7 +974,7 @@ var workingDirectory = Path.join(Os.homedir(), "elek.io");
 var pathTo = {
   tmp: Path.join(workingDirectory, "tmp"),
   userFile: Path.join(workingDirectory, "user.json"),
-  // logs: Path.join(workingDirectory, 'logs'),
+  logs: Path.join(workingDirectory, "logs"),
   projects: Path.join(workingDirectory, "projects"),
   project: (projectId) => {
     return Path.join(pathTo.projects, projectId);
@@ -1010,11 +1026,11 @@ var pathTo = {
   },
   asset: (projectId, id, extension) => {
     return Path.join(pathTo.lfs(projectId), `${id}.${extension}`);
+  },
+  tmpAsset: (id, extension) => {
+    return Path.join(pathTo.tmp, `${id}.${extension}`);
   }
 };
-function assignDefaultIfMissing(value, defaultsTo) {
-  return Object.assign(defaultsTo, value);
-}
 function notEmpty(value) {
   if (value === null || value === void 0) {
     return false;
@@ -1047,27 +1063,6 @@ async function returnResolved(promises) {
   const checked = await Promise.all(toCheck);
   return checked.filter(isNoError);
 }
-function spawnChildProcess(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const childProcess = spawn(command, args, options);
-    let log = "";
-    childProcess.stdout.on("data", (data) => {
-      log += data;
-    });
-    childProcess.stderr.on("data", (data) => {
-      log += data;
-    });
-    childProcess.on("error", (error) => {
-      throw error;
-    });
-    childProcess.on("exit", (code) => {
-      if (code === 0) {
-        return resolve(log);
-      }
-      return reject(log);
-    });
-  });
-}
 async function folders(path) {
   const dirent = await Fs.readdir(path, { withFileTypes: true });
   return dirent.filter((dirent2) => {
@@ -1091,21 +1086,12 @@ async function files(path, extension) {
 var AbstractCrudService = class {
   type;
   options;
-  /**
-   * Dynamically generated git messages for operations
-   */
-  gitMessage;
   /**
    * Do not instantiate directly as this is an abstract class
    */
   constructor(type, options) {
     this.type = type;
     this.options = options;
-    this.gitMessage = {
-      create: `${gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
-      update: `${gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
-      delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
-    };
   }
   /**
    * Returns a list of all file references of given project and type
@@ -1165,8 +1151,7 @@ var AbstractCrudService = class {
    * Searches for all files inside given folder,
    * parses their names and returns them as FileReference
    *
-   * Ignores files not matching the [id].[language].[extension]
-   * or [id].[extension] format for their names
+   * Ignores files if the extension is not supported.
    */
   async getFileReferences(path) {
     const possibleFiles = await files(path);
@@ -1174,9 +1159,8 @@ var AbstractCrudService = class {
       possibleFiles.map(async (possibleFile) => {
         const fileNameArray = possibleFile.name.split(".");
         const fileReference = {
-          id: fileNameArray[0] || "",
-          language: fileNameArray.length === 3 ? fileNameArray[1] : void 0,
-          extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
+          id: fileNameArray[0],
+          extension: fileNameArray[1]
         };
         try {
           return fileReferenceSchema.parse(fileReference);
@@ -1190,9 +1174,8 @@ var AbstractCrudService = class {
 };
 
 // src/service/AssetService.ts
-import { fileTypeFromFile } from "file-type";
 import Fs2 from "fs-extra";
-import isSvg from "is-svg";
+import mime from "mime";
 
 // src/util/shared.ts
 import slugify from "@sindresorhus/slugify";
@@ -1216,10 +1199,13 @@ function slug(string) {
 
 // src/service/AssetService.ts
 var AssetService = class extends AbstractCrudService {
+  // @ts-ignore
+  logService;
   jsonFileService;
   gitService;
-  constructor(options, jsonFileService, gitService) {
+  constructor(options, logService, jsonFileService, gitService) {
     super(serviceTypeSchema.Enum.Asset, options);
+    this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -1230,12 +1216,13 @@ var AssetService = class extends AbstractCrudService {
     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);
+    const fileType = this.getFileType(props.filePath);
+    const size = await this.getFileSize(props.filePath);
     const assetPath = pathTo.asset(props.projectId, id, fileType.extension);
     const assetFilePath = pathTo.assetFile(props.projectId, id);
     const assetFile = {
       ...props,
+      name: slug(props.name),
       objectType: "asset",
       id,
       created: datetime(),
@@ -1256,19 +1243,56 @@ var AssetService = class extends AbstractCrudService {
       throw error;
     }
     await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: { objectType: "asset", id }
+    });
     return this.toAsset(props.projectId, assetFile);
   }
   /**
    * Returns an Asset by ID
+   *
+   * If a commit hash is provided, the Asset is read from history
    */
   async read(props) {
     readAssetSchema.parse(props);
-    const assetFile = await this.jsonFileService.read(
-      pathTo.assetFile(props.projectId, props.id),
-      assetFileSchema
-    );
-    return this.toAsset(props.projectId, assetFile);
+    if (!props.commitHash) {
+      const assetFile = await this.jsonFileService.read(
+        pathTo.assetFile(props.projectId, props.id),
+        assetFileSchema
+      );
+      return this.toAsset(props.projectId, assetFile);
+    } else {
+      const assetFile = this.migrate(
+        JSON.parse(
+          await this.gitService.getFileContentAtCommit(
+            pathTo.project(props.projectId),
+            pathTo.assetFile(props.projectId, props.id),
+            props.commitHash
+          )
+        )
+      );
+      const assetBlob = await this.gitService.getFileContentAtCommit(
+        pathTo.project(props.projectId),
+        pathTo.asset(props.projectId, props.id, assetFile.extension),
+        props.commitHash,
+        "binary"
+      );
+      await Fs2.writeFile(
+        pathTo.tmpAsset(assetFile.id, assetFile.extension),
+        assetBlob,
+        "binary"
+      );
+      return this.toAsset(props.projectId, assetFile, true);
+    }
+  }
+  /**
+   * Copies an Asset to given file path on disk
+   */
+  async save(props) {
+    saveAssetSchema.parse(props);
+    const asset = await this.read(props);
+    await Fs2.copyFile(asset.absolutePath, props.filePath);
   }
   /**
    * Updates given Asset
@@ -1283,13 +1307,12 @@ var AssetService = class extends AbstractCrudService {
     const assetFile = {
       ...prevAssetFile,
       ...props,
+      name: slug(props.name),
       updated: datetime()
     };
     if (props.newFilePath) {
-      const fileType = await this.getSupportedFileTypeOrThrow(
-        props.newFilePath
-      );
-      const size = await this.getAssetSize(props.newFilePath);
+      const fileType = this.getFileType(props.newFilePath);
+      const size = await this.getFileSize(props.newFilePath);
       const prevAssetPath = pathTo.asset(
         props.projectId,
         props.id,
@@ -1302,6 +1325,7 @@ var AssetService = class extends AbstractCrudService {
       );
       await Fs2.remove(prevAssetPath);
       await Fs2.copyFile(props.newFilePath, assetPath);
+      await this.gitService.add(projectPath, [prevAssetPath, assetPath]);
       assetFile.extension = fileType.extension;
       assetFile.mimeType = fileType.mimeType;
       assetFile.size = size;
@@ -1312,7 +1336,10 @@ var AssetService = class extends AbstractCrudService {
       assetFileSchema
     );
     await this.gitService.add(projectPath, [assetFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "asset", id: assetFile.id }
+    });
     return this.toAsset(props.projectId, assetFile);
   }
   /**
@@ -1326,7 +1353,10 @@ var AssetService = class extends AbstractCrudService {
     await Fs2.remove(assetPath);
     await Fs2.remove(assetFilePath);
     await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: { objectType: "asset", id: props.id }
+    });
   }
   async list(props) {
     listAssetsSchema.parse(props);
@@ -1364,11 +1394,11 @@ var AssetService = class extends AbstractCrudService {
     return assetSchema.safeParse(obj).success;
   }
   /**
-   * Returns the size of an Asset in bytes
+   * Returns the size of an file in bytes
    *
-   * @param path Path of the Asset to get the size from
+   * @param path Path of the file to get the size from
    */
-  async getAssetSize(path) {
+  async getFileSize(path) {
     return (await Fs2.stat(path)).size;
   }
   /**
@@ -1377,15 +1407,15 @@ var AssetService = class extends AbstractCrudService {
    * @param projectId   The project's ID
    * @param assetFile   The AssetFile to convert
    */
-  async toAsset(projectId, assetFile) {
-    const assetPath = pathTo.asset(
-      projectId,
-      assetFile.id,
-      assetFile.extension
-    );
+  async toAsset(projectId, assetFile, isFromHistory = false) {
+    const assetPath = isFromHistory === false ? pathTo.asset(projectId, assetFile.id, assetFile.extension) : pathTo.tmpAsset(assetFile.id, assetFile.extension);
+    const history = await this.gitService.log(pathTo.project(projectId), {
+      filePath: pathTo.assetFile(projectId, assetFile.id)
+    });
     const asset = {
       ...assetFile,
-      absolutePath: assetPath
+      absolutePath: assetPath,
+      history
     };
     return asset;
   }
@@ -1395,23 +1425,27 @@ var AssetService = class extends AbstractCrudService {
    *
    * @param filePath Path to the file to check
    */
-  async getSupportedFileTypeOrThrow(filePath) {
-    const fileSize = (await Fs2.stat(filePath)).size;
-    if (fileSize / 1e3 <= 500) {
-      const fileBuffer = await Fs2.readFile(filePath);
-      if (isSvg(fileBuffer.toString()) === true) {
-        return {
-          extension: supportedAssetExtensionSchema.Enum.svg,
-          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
-        };
-      }
+  getFileType(filePath) {
+    const mimeType = mime.getType(filePath);
+    if (mimeType === null) {
+      throw new Error(`Unsupported MIME type of file "${filePath}"`);
     }
-    const fileType = await fileTypeFromFile(filePath);
-    const result = supportedAssetTypeSchema.parse({
-      extension: fileType?.ext,
-      mimeType: fileType?.mime
-    });
-    return result;
+    const extension = mime.getExtension(mimeType);
+    if (extension === null) {
+      throw new Error(
+        `Unsupported extension for MIME type "${mimeType}" of file "${filePath}"`
+      );
+    }
+    return {
+      extension,
+      mimeType
+    };
+  }
+  /**
+   * Migrates an potentially outdated Asset file to the current schema
+   */
+  migrate(potentiallyOutdatedAssetFile) {
+    return assetFileSchema.parse(potentiallyOutdatedAssetFile);
   }
 };
 
@@ -1452,19 +1486,37 @@ var CollectionService = class extends AbstractCrudService {
       collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return collectionFile;
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: { objectType: "collection", id }
+    });
+    return this.toCollection(props.projectId, collectionFile);
   }
   /**
    * Returns a Collection by ID
+   *
+   * If a commit hash is provided, the Collection is read from history
    */
   async read(props) {
     readCollectionSchema.parse(props);
-    const collection = await this.jsonFileService.read(
-      pathTo.collectionFile(props.projectId, props.id),
-      collectionFileSchema
-    );
-    return collection;
+    if (!props.commitHash) {
+      const collectionFile = await this.jsonFileService.read(
+        pathTo.collectionFile(props.projectId, props.id),
+        collectionFileSchema
+      );
+      return this.toCollection(props.projectId, collectionFile);
+    } else {
+      const collectionFile = this.migrate(
+        JSON.parse(
+          await this.gitService.getFileContentAtCommit(
+            pathTo.project(props.projectId),
+            pathTo.collectionFile(props.projectId, props.id),
+            props.commitHash
+          )
+        )
+      );
+      return this.toCollection(props.projectId, collectionFile);
+    }
   }
   /**
    * Updates given Collection
@@ -1492,8 +1544,11 @@ var CollectionService = class extends AbstractCrudService {
       collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return collectionFile;
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "collection", id: collectionFile.id }
+    });
+    return this.toCollection(props.projectId, collectionFile);
   }
   /**
    * Deletes given Collection (folder), including it's items
@@ -1506,7 +1561,10 @@ var CollectionService = class extends AbstractCrudService {
     const collectionPath = pathTo.collection(props.projectId, props.id);
     await Fs3.remove(collectionPath);
     await this.gitService.add(projectPath, [collectionPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: { objectType: "collection", id: props.id }
+    });
   }
   async list(props) {
     listCollectionsSchema.parse(props);
@@ -1549,18 +1607,42 @@ var CollectionService = class extends AbstractCrudService {
   isCollection(obj) {
     return collectionFileSchema.safeParse(obj).success;
   }
+  /**
+   * Migrates an potentially outdated Collection file to the current schema
+   */
+  migrate(potentiallyOutdatedCollectionFile) {
+    return collectionFileSchema.parse(potentiallyOutdatedCollectionFile);
+  }
+  /**
+   * Creates an Collection from given CollectionFile
+   *
+   * @param projectId   The project's ID
+   * @param collectionFile   The CollectionFile to convert
+   */
+  async toCollection(projectId, collectionFile) {
+    const history = await this.gitService.log(pathTo.project(projectId), {
+      filePath: pathTo.collectionFile(projectId, collectionFile.id)
+    });
+    const collection = {
+      ...collectionFile,
+      history
+    };
+    return collection;
+  }
 };
 
 // src/service/EntryService.ts
 import Fs4 from "fs-extra";
 var EntryService = class extends AbstractCrudService {
+  logService;
   jsonFileService;
   gitService;
   collectionService;
   assetService;
   // private sharedValueService: SharedValueService;
-  constructor(options, jsonFileService, gitService, collectionService, assetService) {
+  constructor(options, logService, jsonFileService, gitService, collectionService, assetService) {
     super(serviceTypeSchema.Enum.Entry, options);
+    this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
@@ -1589,11 +1671,11 @@ var EntryService = class extends AbstractCrudService {
       created: datetime(),
       updated: null
     };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
+    const entry = await this.toEntry(
+      props.projectId,
+      props.collectionId,
       entryFile
-    });
+    );
     this.validateValues({
       collectionId: props.collectionId,
       fieldDefinitions: collection.fieldDefinitions,
@@ -1605,23 +1687,41 @@ var EntryService = class extends AbstractCrudService {
       entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: {
+        objectType: "entry",
+        id: entryFile.id,
+        collectionId: props.collectionId
+      }
+    });
     return entry;
   }
   /**
-   * Returns an Entry from given Collection by ID and language
+   * Returns an Entry from given Collection by ID
+   *
+   * If a commit hash is provided, the Entry is read from history
    */
   async read(props) {
     readEntrySchema.parse(props);
-    const entryFile = await this.jsonFileService.read(
-      pathTo.entryFile(props.projectId, props.collectionId, props.id),
-      entryFileSchema
-    );
-    return await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
-      entryFile
-    });
+    if (!props.commitHash) {
+      const entryFile = await this.jsonFileService.read(
+        pathTo.entryFile(props.projectId, props.collectionId, props.id),
+        entryFileSchema
+      );
+      return this.toEntry(props.projectId, props.collectionId, entryFile);
+    } else {
+      const entryFile = this.migrate(
+        JSON.parse(
+          await this.gitService.getFileContentAtCommit(
+            pathTo.project(props.projectId),
+            pathTo.entryFile(props.projectId, props.collectionId, props.id),
+            props.commitHash
+          )
+        )
+      );
+      return this.toEntry(props.projectId, props.collectionId, entryFile);
+    }
   }
   /**
    * Updates an Entry of given Collection with new Values and shared Values
@@ -1648,11 +1748,11 @@ var EntryService = class extends AbstractCrudService {
       values: props.values,
       updated: datetime()
     };
-    const entry = await this.toEntry({
-      projectId: props.projectId,
-      collectionId: props.collectionId,
+    const entry = await this.toEntry(
+      props.projectId,
+      props.collectionId,
       entryFile
-    });
+    );
     this.validateValues({
       collectionId: props.collectionId,
       fieldDefinitions: collection.fieldDefinitions,
@@ -1664,7 +1764,14 @@ var EntryService = class extends AbstractCrudService {
       entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: {
+        objectType: "entry",
+        id: entryFile.id,
+        collectionId: props.collectionId
+      }
+    });
     return entry;
   }
   /**
@@ -1680,7 +1787,14 @@ var EntryService = class extends AbstractCrudService {
     );
     await Fs4.remove(entryFilePath);
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: {
+        objectType: "entry",
+        id: props.id,
+        collectionId: props.collectionId
+      }
+    });
   }
   async list(props) {
     listEntriesSchema.parse(props);
@@ -1722,6 +1836,12 @@ var EntryService = class extends AbstractCrudService {
   isEntry(obj) {
     return entrySchema.safeParse(obj).success;
   }
+  /**
+   * Migrates an potentially outdated Entry file to the current schema
+   */
+  migrate(potentiallyOutdatedEntryFile) {
+    return entryFileSchema.parse(potentiallyOutdatedEntryFile);
+  }
   /**
    * Returns a Field definition by ID
    */
@@ -1750,14 +1870,16 @@ var EntryService = class extends AbstractCrudService {
         id: value.fieldDefinitionId
       });
       const contentSchema = getValueContentSchemaFromFieldDefinition(fieldDefinition);
-      try {
-        for (const [_language, content] of Object.entries(value.content)) {
-          contentSchema.parse(content);
+      this.logService.debug(
+        "Validating Value against content schema generated from Field definition",
+        {
+          value,
+          contentSchema,
+          fieldDefinition
         }
-      } catch (error) {
-        console.log("Definition:", fieldDefinition);
-        console.log("Value:", value);
-        throw error;
+      );
+      for (const [_language, content] of Object.entries(value.content)) {
+        contentSchema.parse(content);
       }
     });
   }
@@ -1827,16 +1949,20 @@ var EntryService = class extends AbstractCrudService {
   /**
    * Creates an Entry from given EntryFile by resolving it's Values
    */
-  async toEntry(props) {
+  async toEntry(projectId, collectionId, entryFile) {
+    const history = await this.gitService.log(pathTo.project(projectId), {
+      filePath: pathTo.entryFile(projectId, collectionId, entryFile.id)
+    });
     return {
-      ...props.entryFile,
+      ...entryFile,
+      history,
       // @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) => {
+        entryFile.values.map(async (value) => {
           if (value.valueType === ValueTypeSchema.Enum.reference) {
             const resolvedContentReferences = await this.resolveValueContentReferences({
-              projectId: props.projectId,
-              collectionId: props.collectionId,
+              projectId,
+              collectionId,
               valueReference: value
             });
             return {
@@ -1853,11 +1979,10 @@ var EntryService = class extends AbstractCrudService {
 
 // src/service/GitService.ts
 import { GitProcess } from "dugite";
-import { EOL as EOL2 } from "os";
 import PQueue from "p-queue";
+import Path2 from "path";
 
 // src/service/GitTagService.ts
-import { EOL } from "os";
 var GitTagService = class extends AbstractCrudService {
   git;
   constructor(options, git) {
@@ -1940,7 +2065,7 @@ var GitTagService = class extends AbstractCrudService {
       "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:iso-strict)"
     ];
     const result = await this.git(props.path, args);
-    const noEmptyLinesArr = result.stdout.split(EOL).filter((line) => {
+    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
       return line.trim() !== "";
     });
     const lineObjArr = noEmptyLinesArr.map((line) => {
@@ -1991,16 +2116,18 @@ var GitService = class {
   version;
   gitPath;
   queue;
+  logService;
   gitTagService;
   userService;
-  constructor(options, userService) {
+  constructor(options, logService, userService) {
     this.version = null;
     this.gitPath = null;
     this.queue = new PQueue({
       concurrency: 1
       // No concurrency because git operations are sequencial
     });
-    this.gitTagService = new GitTagService(options, this.git);
+    this.gitTagService = new GitTagService(options, this.git.bind(this));
+    this.logService = logService;
     this.userService = userService;
     this.updateVersion();
     this.updateGitPath();
@@ -2026,7 +2153,6 @@ var GitService = class {
     }
     await this.git(path, args);
     await this.setLocalConfig(path);
-    await this.installLfs(path);
   }
   /**
    * Clone a repository into a directory
@@ -2042,6 +2168,9 @@ var GitService = class {
    */
   async clone(url, path, options) {
     let args = ["clone", "--progress"];
+    if (options?.bare) {
+      args = [...args, "--bare"];
+    }
     if (options?.branch) {
       args = [...args, "--branch", options.branch];
     }
@@ -2063,9 +2192,25 @@ var GitService = class {
    * @param files Files to add
    */
   async add(path, files2) {
-    const args = ["add", "--", ...files2];
+    const relativePathsFromRepositoryRoot = files2.map((filePath) => {
+      return filePath.replace(`${path}${Path2.sep}`, "");
+    });
+    const args = ["add", "--", ...relativePathsFromRepositoryRoot];
     await this.git(path, args);
   }
+  async status(path) {
+    const args = ["status", "--porcelain=2"];
+    const result = await this.git(path, args);
+    const normalizedLinesArr = result.stdout.split("\n").filter((line) => {
+      return line.trim() !== "";
+    }).map((line) => {
+      const lineArr = line.trim().split(" ");
+      return {
+        filePath: lineArr[8]
+      };
+    });
+    return normalizedLinesArr;
+  }
   branches = {
     /**
      * List branches
@@ -2077,7 +2222,7 @@ var GitService = class {
     list: async (path) => {
       const args = ["branch", "--list", "--all"];
       const result = await this.git(path, args);
-      const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
+      const normalizedLinesArr = result.stdout.split("\n").filter((line) => {
         return line.trim() !== "";
       }).map((line) => {
         return line.trim().replace("* ", "");
@@ -2126,6 +2271,21 @@ var GitService = class {
         args = [...args, branch];
       }
       await this.git(path, args);
+    },
+    /**
+     * Delete a branch
+     *
+     * @see https://git-scm.com/docs/git-branch#Documentation/git-branch.txt---delete
+     *
+     * @param path Path to the repository
+     * @param branch Name of the branch to delete
+     */
+    delete: async (path, branch, force) => {
+      let args = ["branch", "--delete"];
+      if (force === true) {
+        args = [...args, "--force"];
+      }
+      await this.git(path, [...args, branch]);
     }
   };
   remotes = {
@@ -2139,7 +2299,7 @@ var GitService = class {
     list: async (path) => {
       const args = ["remote"];
       const result = await this.git(path, args);
-      const normalizedLinesArr = result.stdout.split(EOL2).filter((line) => {
+      const normalizedLinesArr = result.stdout.split("\n").filter((line) => {
         return line.trim() !== "";
       });
       return normalizedLinesArr;
@@ -2166,7 +2326,7 @@ var GitService = class {
      * @param path  Path to the repository
      */
     addOrigin: async (path, url) => {
-      const args = ["remote", "add", "origin", url];
+      const args = ["remote", "add", "origin", url.trim()];
       await this.git(path, args);
     },
     /**
@@ -2193,10 +2353,23 @@ var GitService = class {
      * @param path  Path to the repository
      */
     setOriginUrl: async (path, url) => {
-      const args = ["remote", "set-url", "origin", url];
+      const args = ["remote", "set-url", "origin", url.trim()];
       await this.git(path, args);
     }
   };
+  /**
+   * Join two development histories together
+   *
+   * @see https://git-scm.com/docs/git-merge
+   */
+  async merge(path, branch, options) {
+    let args = ["merge"];
+    if (options?.squash === true) {
+      args = [...args, "--squash"];
+    }
+    args = [...args, branch];
+    await this.git(path, args);
+  }
   /**
    * Reset current HEAD to the specified state
    *
@@ -2278,16 +2451,17 @@ var GitService = class {
    * @see https://git-scm.com/docs/git-commit
    *
    * @param path    Path to the repository
-   * @param message A message that describes the changes
+   * @param message An object describing the changes
    */
   async commit(path, message) {
+    gitMessageSchema.parse(message);
     const user = await this.userService.get();
     if (!user) {
       throw new NoCurrentUserError();
     }
     const args = [
       "commit",
-      `--message=${message}`,
+      `--message=${JSON.stringify(message)}`,
       `--author=${user.name} <${user.email}>`
     ];
     await this.git(path, args);
@@ -2314,28 +2488,54 @@ var GitService = class {
     if (options?.limit) {
       args = [...args, `--max-count=${options.limit}`];
     }
-    const result = await this.git(path, [
-      ...args,
-      "--format=%H|%s|%an|%ae|%aI|%D"
-    ]);
-    const noEmptyLinesArr = result.stdout.split(EOL2).filter((line) => {
+    args = [...args, "--format=%H|%s|%an|%ae|%aI|%D"];
+    if (options?.filePath) {
+      args = [...args, "--", options.filePath];
+    }
+    const result = await this.git(path, args);
+    const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
       return line.trim() !== "";
     });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        hash: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        datetime: datetime(lineArray[4]),
-        tag: this.refNameToTagName(lineArray[5] || "")
-      };
-    });
+    const lineObjArr = await Promise.all(
+      noEmptyLinesArr.map(async (line) => {
+        const lineArray = line.split("|");
+        const tagId = this.refNameToTagName(lineArray[5] || "");
+        const tag = tagId ? await this.tags.read({ path, id: tagId }) : null;
+        return {
+          hash: lineArray[0],
+          message: JSON.parse(lineArray[1] || ""),
+          author: {
+            name: lineArray[2],
+            email: lineArray[3]
+          },
+          datetime: datetime(lineArray[4]),
+          tag
+        };
+      })
+    );
     return lineObjArr.filter(this.isGitCommit.bind(this));
   }
+  /**
+   * Retrieves the content of a file at a specific commit
+   *
+   * @see https://git-scm.com/docs/git-show
+   */
+  async getFileContentAtCommit(path, filePath, commitHash, encoding = "utf8") {
+    const relativePathFromRepositoryRoot = filePath.replace(
+      `${path}${Path2.sep}`,
+      ""
+    );
+    const normalizedPath = relativePathFromRepositoryRoot.split("\\").join("/");
+    const args = ["show", `${commitHash}:${normalizedPath}`];
+    const setEncoding = (cb) => {
+      if (cb.stdout) {
+        cb.stdout.setEncoding(encoding);
+      }
+    };
+    return (await this.git(path, args, {
+      processCallback: setEncoding
+    })).stdout;
+  }
   refNameToTagName(refName) {
     const tagName = refName.replace("tag: ", "").trim();
     if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
@@ -2375,16 +2575,6 @@ var GitService = class {
   async checkBranchOrTagName(path, name) {
     await this.git(path, ["check-ref-format", "--allow-onelevel", name]);
   }
-  /**
-   * Installs LFS support and starts tracking
-   * all files inside the lfs folder
-   *
-   * @param path Path to the repository
-   */
-  async installLfs(path) {
-    await this.git(path, ["lfs", "install"]);
-    await this.git(path, ["lfs", "track", "lfs/*"]);
-  }
   /**
    * Sets the git config of given local repository from ElekIoCoreOptions
    *
@@ -2422,31 +2612,37 @@ var GitService = class {
    * @param path Path to the repository
    * @param args Arguments to append after the `git` command
    */
-  async git(path, args) {
-    const result = await this.queue.add(
-      () => GitProcess.exec(args, path, {
-        env: {
-          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
-          // @see https://github.com/git-lfs/git-lfs/issues/5749
-          GIT_CLONE_PROTECTION_ACTIVE: "false"
-        }
-      })
-    );
+  async git(path, args, options) {
+    const result = await this.queue.add(async () => {
+      const start = Date.now();
+      const gitResult = await GitProcess.exec(args, path, options);
+      const durationMs = Date.now() - start;
+      return {
+        gitResult,
+        durationMs
+      };
+    });
     if (!result) {
       throw new GitError(
         `Git ${this.version} (${this.gitPath}) command "git ${args.join(
           " "
-        )}" failed to return a result`
+        )}" executed for "${path}" failed to return a result`
       );
     }
-    if (result.exitCode !== 0) {
+    const gitLog = `Executed "git ${args.join(" ")}" in ${result.durationMs}ms`;
+    if (result.durationMs >= 100) {
+      this.logService.warn(gitLog);
+    } else {
+      this.logService.debug(gitLog);
+    }
+    if (result.gitResult.exitCode !== 0) {
       throw new GitError(
         `Git ${this.version} (${this.gitPath}) command "git ${args.join(
           " "
-        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
+        )}" executed for "${path}" failed with exit code "${result.gitResult.exitCode}" and message "${result.gitResult.stderr.trim() || result.gitResult.stdout.trim()}"`
       );
     }
-    return result;
+    return result.gitResult;
   }
 };
 
@@ -2454,8 +2650,10 @@ var GitService = class {
 import Fs5 from "fs-extra";
 var JsonFileService = class extends AbstractCrudService {
   cache = /* @__PURE__ */ new Map();
-  constructor(options) {
+  logService;
+  constructor(options, logService) {
     super(serviceTypeSchema.Enum.JsonFile, options);
+    this.logService = logService;
   }
   /**
    * Creates a new file on disk. Fails if path already exists
@@ -2472,7 +2670,8 @@ var JsonFileService = class extends AbstractCrudService {
       flag: "wx",
       encoding: "utf8"
     });
-    this.cache.set(path, parsedData);
+    this.options.file.cache === true && this.cache.set(path, parsedData);
+    this.logService.debug(`Created file "${path}"`);
     return parsedData;
   }
   /**
@@ -2483,18 +2682,43 @@ var JsonFileService = class extends AbstractCrudService {
    * @returns Validated content of the file from disk
    */
   async read(path, schema) {
-    if (this.cache.has(path)) {
-      return this.cache.get(path);
+    if (this.options.file.cache === true && this.cache.has(path)) {
+      this.logService.debug(`Cache hit reading file "${path}"`);
+      const json2 = this.cache.get(path);
+      const parsedData2 = schema.parse(json2);
+      return parsedData2;
     }
+    this.logService.debug(`Cache miss reading file "${path}"`);
     const data = await Fs5.readFile(path, {
       flag: "r",
       encoding: "utf8"
     });
     const json = this.deserialize(data);
     const parsedData = schema.parse(json);
-    this.cache.set(path, parsedData);
+    this.options.file.cache === true && this.cache.set(path, parsedData);
     return parsedData;
   }
+  /**
+   * Reads the content of a file on disk. Fails if path does not exist.
+   * Does not validate the content of the file against a schema and
+   * therefore is only to be used when retrieving data we do not have
+   * a current schema for. E.g. reading from history or while upgrading
+   * the old schema of a file to a new, current schema.
+   *
+   * Does not read from or write to cache.
+   *
+   * @param path Path to read the file from
+   * @returns Unvalidated content of the file from disk
+   */
+  async unsafeRead(path) {
+    this.logService.warn(`Unsafe reading of file "${path}"`);
+    const data = await Fs5.readFile(path, {
+      flag: "r",
+      encoding: "utf8"
+    });
+    const json = this.deserialize(data);
+    return json;
+  }
   /**
    * Overwrites an existing file on disk
    *
@@ -2512,31 +2736,118 @@ var JsonFileService = class extends AbstractCrudService {
       flag: "w",
       encoding: "utf8"
     });
-    this.cache.set(path, parsedData);
+    this.options.file.cache === true && this.cache.set(path, parsedData);
+    this.logService.debug(`Updated file "${path}"`);
     return parsedData;
   }
   serialize(data) {
-    return JSON.stringify(data, null, this.options.file.json.indentation);
+    return JSON.stringify(data, null, 2);
   }
   deserialize(data) {
     return JSON.parse(data);
   }
 };
 
+// src/service/LogService.ts
+import Path3 from "path";
+import {
+  createLogger,
+  format,
+  transports
+} from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+var LogService = class {
+  logger;
+  constructor(options) {
+    const rotatingFileTransport = new DailyRotateFile({
+      filename: Path3.join(pathTo.logs, "core-%DATE%.log"),
+      datePattern: "YYYY-MM-DD",
+      zippedArchive: true,
+      maxFiles: "30d",
+      handleExceptions: true,
+      handleRejections: true,
+      format: format.combine(format.timestamp(), format.json())
+    });
+    this.logger = createLogger({
+      level: options.log.level,
+      transports: [
+        rotatingFileTransport,
+        new transports.Console({
+          handleExceptions: true,
+          handleRejections: true,
+          format: format.combine(
+            format.colorize(),
+            format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+            format.printf((info) => {
+              return `${info.level} [${info["timestamp"]}]: ${info.message}`;
+            })
+          )
+        })
+      ]
+    });
+    rotatingFileTransport.on("rotate", (oldFilename, newFilename) => {
+      this.logger.info(
+        `Rotated log file from ${oldFilename} to ${newFilename}`
+      );
+    });
+  }
+  debug(message, ...meta) {
+    this.logger.debug(message, ...meta);
+  }
+  info(message, ...meta) {
+    this.logger.info(message, ...meta);
+  }
+  warn(message, ...meta) {
+    this.logger.warn(message, ...meta);
+  }
+  error(message, ...meta) {
+    this.logger.error(message, ...meta);
+  }
+  read(options) {
+    return this.logger.query(options);
+  }
+};
+
 // src/service/ProjectService.ts
 import Fs6 from "fs-extra";
 import Os2 from "os";
-import Path2 from "path";
+import Path4 from "path";
 import Semver from "semver";
+
+// src/error/RemoteOriginMissingError.ts
+var RemoteOriginMissingError = class extends Error {
+  constructor(projectId) {
+    super(
+      `Tried to delete Project "${projectId}" but it does not have a remote origin. Deleting a Project without a remote origin could lead to data loss. Use the "force" option to delete it anyway.`
+    );
+    this.name = "RemoteOriginMissingError";
+  }
+};
+
+// src/error/SynchronizeLocalChangesError.ts
+var SynchronizeLocalChangesError = class extends Error {
+  constructor(projectId) {
+    super(
+      `Tried to delete Project "${projectId}" but it has local changes that are not yet pushed to the remote origin. Deleting a Project with local changes could lead to data loss. Use the "force" option to delete it anyway.`
+    );
+    this.name = "SynchronizeLocalChangesError";
+  }
+};
+
+// src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
+  coreVersion;
+  logService;
   jsonFileService;
   userService;
   gitService;
   assetService;
   collectionService;
   entryService;
-  constructor(options, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
+  constructor(coreVersion, options, logService, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
     super(serviceTypeSchema.Enum.Project, options);
+    this.coreVersion = coreVersion;
+    this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
@@ -2568,8 +2879,7 @@ var ProjectService = class extends AbstractCrudService {
       settings: Object.assign({}, defaultSettings, props.settings),
       created: datetime(),
       updated: null,
-      coreVersion: this.options.version,
-      // @todo should be read from package.json to avoid duplicates
+      coreVersion: this.coreVersion,
       status: "todo",
       version: "0.0.1"
     };
@@ -2578,29 +2888,34 @@ var ProjectService = class extends AbstractCrudService {
     try {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
-      await this.gitService.init(projectPath, { initialBranch: "main" });
+      await this.gitService.init(projectPath, {
+        initialBranch: projectBranchSchema.Enum.production
+      });
       await this.jsonFileService.create(
         projectFile,
         pathTo.projectFile(id),
         projectFileSchema
       );
       await this.gitService.add(projectPath, ["."]);
-      await this.gitService.commit(
+      await this.gitService.commit(projectPath, {
+        method: "create",
+        reference: { objectType: "project", id }
+      });
+      await this.gitService.branches.switch(
         projectPath,
-        `${gitCommitIconSchema.enum.INIT} Created this new elek.io project`
+        projectBranchSchema.Enum.work,
+        {
+          isNew: true
+        }
       );
-      await this.gitService.branches.switch(projectPath, "stage", {
-        isNew: true
-      });
     } catch (error) {
       await this.delete({
-        id
+        id,
+        force: true
       });
       throw error;
     }
-    return await this.toProject({
-      projectFile
-    });
+    return await this.toProject(projectFile);
   }
   /**
    * Clones a Project by URL
@@ -2608,10 +2923,10 @@ var ProjectService = class extends AbstractCrudService {
   async clone(props) {
     cloneProjectSchema.parse(props);
     const tmpId = uuid();
-    const tmpProjectPath = Path2.join(pathTo.tmp, tmpId);
+    const tmpProjectPath = Path4.join(pathTo.tmp, tmpId);
     await this.gitService.clone(props.url, tmpProjectPath);
     const projectFile = await this.jsonFileService.read(
-      Path2.join(tmpProjectPath, "project.json"),
+      Path4.join(tmpProjectPath, "project.json"),
       projectFileSchema
     );
     const projectPath = pathTo.project(projectFile.id);
@@ -2623,22 +2938,33 @@ var ProjectService = class extends AbstractCrudService {
     }
     await Fs6.copy(tmpProjectPath, projectPath);
     await Fs6.remove(tmpProjectPath);
-    return await this.toProject({
-      projectFile
-    });
+    return await this.toProject(projectFile);
   }
   /**
    * Returns a Project by ID
+   *
+   * If a commit hash is provided, the Project is read from history
    */
   async read(props) {
     readProjectSchema.parse(props);
-    const projectFile = await this.jsonFileService.read(
-      pathTo.projectFile(props.id),
-      projectFileSchema
-    );
-    return await this.toProject({
-      projectFile
-    });
+    if (!props.commitHash) {
+      const projectFile = await this.jsonFileService.read(
+        pathTo.projectFile(props.id),
+        projectFileSchema
+      );
+      return await this.toProject(projectFile);
+    } else {
+      const projectFile = this.migrate(
+        JSON.parse(
+          await this.gitService.getFileContentAtCommit(
+            pathTo.project(props.id),
+            pathTo.projectFile(props.id),
+            props.commitHash
+          )
+        )
+      );
+      return await this.toProject(projectFile);
+    }
   }
   /**
    * Updates given Project
@@ -2652,6 +2978,7 @@ var ProjectService = class extends AbstractCrudService {
       ...prevProjectFile,
       name: props.name || prevProjectFile.name,
       description: props.description || prevProjectFile.description,
+      coreVersion: this.coreVersion,
       settings: {
         language: {
           supported: props.settings?.language.supported || prevProjectFile.settings.language.supported,
@@ -2662,83 +2989,131 @@ var ProjectService = class extends AbstractCrudService {
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return await this.toProject({
-      projectFile
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "project", id: projectFile.id }
     });
+    return await this.toProject(projectFile);
   }
   /**
-   * Upgrades given Project to the latest version of this client
-   *
-   * Needed when a new core version is requiring changes to existing files or structure.
+   * Upgrades given Project to the current version of Core
    *
-   * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
+   * Needed when a new Core version is requiring changes to existing files or structure.
    */
   async upgrade(props) {
     upgradeProjectSchema.parse(props);
-    const project = await this.read(props);
-    const projectPath = pathTo.project(project.id);
-    if (Semver.gt(project.coreVersion, this.options.version)) {
-      throw new Error(
-        `Failed upgrading project. The projects core version "${project.coreVersion}" is higher than the current core version "${this.options.version}" of this client. A client upgrade is needed beforehand.`
+    const projectPath = pathTo.project(props.id);
+    const projectFilePath = pathTo.projectFile(props.id);
+    const currentBranch = await this.gitService.branches.current(projectPath);
+    if (currentBranch !== projectBranchSchema.Enum.work) {
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
       );
     }
-    if (Semver.eq(project.coreVersion, this.options.version)) {
-      return;
+    const currentProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
+    if (Semver.gt(currentProjectFile.coreVersion, this.coreVersion)) {
+      throw new ProjectUpgradeError(
+        `The Projects Core version "${currentProjectFile.coreVersion}" is higher than the current Core version "${this.coreVersion}".`
+      );
+    }
+    if (Semver.eq(currentProjectFile.coreVersion, this.coreVersion) && props.force !== true) {
+      throw new ProjectUpgradeError(
+        `The Projects Core version "${currentProjectFile.coreVersion}" is already up to date.`
+      );
     }
-    const upgradeFiles = await files(
-      Path2.resolve(__dirname, "../upgrade"),
-      "ts"
+    const assetReferences = await this.listReferences("asset", props.id);
+    const collectionReferences = await this.listReferences(
+      "collection",
+      props.id
     );
-    const upgrades = (await Promise.all(
-      upgradeFiles.map((file) => {
-        return import(Path2.join("../upgrade", file.name));
-      })
-    )).map((upgradeImport) => {
-      return upgradeImport.default;
-    });
-    const sortedUpgrades = upgrades.sort((a, b) => {
-      return Semver.compare(a.to, b.to);
-    }).filter((upgrade) => {
-      if (upgrade.to !== "0.0.0") {
-        return upgrade;
-      }
-      return;
+    this.logService.info(
+      `Attempting to upgrade Project "${props.id}" from Core version ${currentProjectFile.coreVersion} to ${this.coreVersion}`
+    );
+    const upgradeBranchName = `upgrade/core-${currentProjectFile.coreVersion}-to-${this.coreVersion}`;
+    await this.gitService.branches.switch(projectPath, upgradeBranchName, {
+      isNew: true
     });
-    for (let index = 0; index < sortedUpgrades.length; index++) {
-      const upgrade = sortedUpgrades[index];
-      if (!upgrade) {
-        throw new Error("Expected ProjectUpgrade but got undefined");
-      }
-      const failsafeTag = await this.gitService.tags.create({
+    try {
+      await Promise.all(
+        assetReferences.map(async (reference) => {
+          await this.upgradeObjectFile(props.id, "asset", reference);
+        })
+      );
+      await Promise.all(
+        collectionReferences.map(async (reference) => {
+          await this.upgradeObjectFile(props.id, "collection", reference);
+        })
+      );
+      await Promise.all(
+        collectionReferences.map(async (collectionReference) => {
+          const entryReferences = await this.listReferences(
+            "entry",
+            props.id,
+            collectionReference.id
+          );
+          await Promise.all(
+            entryReferences.map(async (reference) => {
+              await this.upgradeObjectFile(
+                props.id,
+                "entry",
+                reference,
+                collectionReference.id
+              );
+            })
+          );
+        })
+      );
+      const migratedProjectFile = this.migrate(currentProjectFile);
+      await this.update(migratedProjectFile);
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
+      );
+      await this.gitService.merge(projectPath, upgradeBranchName, {
+        squash: true
+      });
+      await this.gitService.commit(projectPath, {
+        method: "upgrade",
+        reference: { objectType: "project", id: migratedProjectFile.id }
+      });
+      await this.gitService.tags.create({
         path: projectPath,
-        message: `Attempting to upgrade Project to Core version "${upgrade.to}"`
+        message: `Upgraded Project to Core version ${migratedProjectFile.coreVersion}`
       });
-      try {
-        await upgrade.run(project);
-        project.coreVersion = upgrade.to;
-        await this.update(project);
-        await this.gitService.tags.create({
-          path: projectPath,
-          message: `Upgraded Project to Core version "${upgrade.to}"`
-        });
-        await this.gitService.tags.delete({
-          path: projectPath,
-          id: failsafeTag.id
-        });
-      } catch (error) {
-        await this.gitService.reset(projectPath, "hard", failsafeTag.id);
-        throw new ProjectUpgradeError(
-          `Failed to upgrade Project to Core version "${upgrade.to}"`
-        );
-      }
+      await this.gitService.branches.delete(
+        projectPath,
+        upgradeBranchName,
+        true
+      );
+      this.logService.info(
+        `Upgraded Project "${projectFilePath}" to Core version "${this.coreVersion}"`,
+        {
+          previous: currentProjectFile,
+          migrated: migratedProjectFile
+        }
+      );
+    } catch (error) {
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
+      );
+      await this.gitService.branches.delete(
+        projectPath,
+        upgradeBranchName,
+        true
+      );
+      throw error;
     }
   }
   branches = {
     list: async (props) => {
       listBranchesProjectSchema.parse(props);
       const projectPath = pathTo.project(props.id);
-      await this.gitService.fetch(projectPath);
+      const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+      if (hasOrigin) {
+        await this.gitService.fetch(projectPath);
+      }
       return await this.gitService.branches.list(projectPath);
     },
     current: async (props) => {
@@ -2756,33 +3131,37 @@ var ProjectService = class extends AbstractCrudService {
       );
     }
   };
-  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);
-      }
+  /**
+   * Updates the remote origin URL of given Project
+   */
+  async setRemoteOriginUrl(props) {
+    setRemoteOriginUrlProjectSchema.parse(props);
+    const projectPath = pathTo.project(props.id);
+    const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+    if (!hasOrigin) {
+      await this.gitService.remotes.addOrigin(projectPath, props.url);
+    } else {
+      await this.gitService.remotes.setOriginUrl(projectPath, props.url);
     }
-  };
+  }
   /**
    * Returns the differences of the given Projects current branch
    * between the local and remote `origin` (commits ahead & behind)
    *
+   * Throws an error if the Project does not have a remote origin.
+   *
    * - `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 hasRemoteOrigin = await this.gitService.remotes.hasOrigin(
+      projectPath
+    );
+    if (hasRemoteOrigin === false) {
+      throw new Error(`Project "${props.id}" does not have a remote origin`);
+    }
     const currentBranch = await this.gitService.branches.current(projectPath);
     await this.gitService.fetch(projectPath);
     const behind = await this.gitService.log(projectPath, {
@@ -2810,13 +3189,46 @@ var ProjectService = class extends AbstractCrudService {
    * Deletes given Project
    *
    * Deletes the whole Project folder including the history, not only the config file.
-   * Use with caution, since a Project that is only available locally could be lost forever.
-   * Or changes that are not pushed to a remote yet, will be lost too.
+   * Throws in case a Project is only available locally and could be lost forever,
+   * or changes are not pushed to a remote yet.
    */
   async delete(props) {
     deleteProjectSchema.parse(props);
+    const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(
+      pathTo.project(props.id)
+    );
+    if (hasRemoteOrigin === false && props.force !== true) {
+      throw new RemoteOriginMissingError(props.id);
+    }
+    if (hasRemoteOrigin === true && props.force !== true) {
+      const changes = await this.getChanges({ id: props.id });
+      if (changes.ahead.length > 0) {
+        throw new SynchronizeLocalChangesError(props.id);
+      }
+    }
     await Fs6.remove(pathTo.project(props.id));
   }
+  /**
+   * Lists outdated Projects that need to be upgraded
+   */
+  async listOutdated() {
+    const projectReferences = await this.listReferences(
+      objectTypeSchema.Enum.project
+    );
+    const result = await Promise.all(
+      projectReferences.map(async (reference) => {
+        const json = await this.jsonFileService.unsafeRead(
+          pathTo.projectFile(reference.id)
+        );
+        const projectFile = outdatedProjectSchema.parse(json);
+        if (projectFile.coreVersion !== this.coreVersion) {
+          return projectFile;
+        }
+        return null;
+      })
+    );
+    return result.filter(notEmpty);
+  }
   async list(props) {
     if (props) {
       listProjectsSchema.parse(props);
@@ -2879,11 +3291,32 @@ var ProjectService = class extends AbstractCrudService {
     };
   }
   /**
-   * Creates a Project from given ProjectFile by adding git information
+   * Migrates an potentially outdated Project file to the current schema
+   */
+  migrate(potentiallyOutdatedProjectFile) {
+    return projectFileSchema.parse(potentiallyOutdatedProjectFile);
+  }
+  /**
+   * Creates a Project from given ProjectFile
    */
-  async toProject(props) {
+  async toProject(projectFile) {
+    const projectPath = pathTo.project(projectFile.id);
+    let remoteOriginUrl = null;
+    const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+    if (hasOrigin) {
+      remoteOriginUrl = await this.gitService.remotes.getOriginUrl(projectPath);
+    }
+    const fullHistory = await this.gitService.log(
+      pathTo.project(projectFile.id)
+    );
+    const history = await this.gitService.log(pathTo.project(projectFile.id), {
+      filePath: pathTo.projectFile(projectFile.id)
+    });
     return {
-      ...props.projectFile
+      ...projectFile,
+      remoteOriginUrl,
+      history,
+      fullHistory
     };
   }
   /**
@@ -2895,8 +3328,8 @@ var ProjectService = class extends AbstractCrudService {
     const folders2 = Object.values(projectFolderSchema.Values);
     await Promise.all(
       folders2.map(async (folder) => {
-        await Fs6.mkdirp(Path2.join(path, folder));
-        await Fs6.writeFile(Path2.join(path, folder, ".gitkeep"), "");
+        await Fs6.mkdirp(Path4.join(path, folder));
+        await Fs6.writeFile(Path4.join(path, folder, ".gitkeep"), "");
       })
     );
   }
@@ -2920,14 +3353,80 @@ var ProjectService = class extends AbstractCrudService {
       // projectFolderSchema.Enum.public + '/',
       // projectFolderSchema.Enum.logs + '/',
     ];
-    await Fs6.writeFile(Path2.join(path, ".gitignore"), lines.join(Os2.EOL));
+    await Fs6.writeFile(Path4.join(path, ".gitignore"), lines.join(Os2.EOL));
+  }
+  async upgradeObjectFile(projectId, objectType, reference, collectionId) {
+    switch (objectType) {
+      case "asset": {
+        const assetFilePath = pathTo.assetFile(projectId, reference.id);
+        const prevAssetFile = await this.jsonFileService.unsafeRead(
+          assetFilePath
+        );
+        const migratedAssetFile = this.assetService.migrate(prevAssetFile);
+        await this.assetService.update({ projectId, ...migratedAssetFile });
+        this.logService.info(`Upgraded ${objectType} "${assetFilePath}"`, {
+          previous: prevAssetFile,
+          migrated: migratedAssetFile
+        });
+        return;
+      }
+      case "collection": {
+        const collectionFilePath = pathTo.collectionFile(
+          projectId,
+          reference.id
+        );
+        const prevCollectionFile = await this.jsonFileService.unsafeRead(
+          collectionFilePath
+        );
+        const migratedCollectionFile = this.collectionService.migrate(prevCollectionFile);
+        await this.collectionService.update({
+          projectId,
+          ...migratedCollectionFile
+        });
+        this.logService.info(`Upgraded ${objectType} "${collectionFilePath}"`, {
+          previous: prevCollectionFile,
+          migrated: migratedCollectionFile
+        });
+        return;
+      }
+      case "entry": {
+        if (!collectionId) {
+          throw new RequiredParameterMissingError("collectionId");
+        }
+        const entryFilePath = pathTo.entryFile(
+          projectId,
+          collectionId,
+          reference.id
+        );
+        const prevEntryFile = await this.jsonFileService.unsafeRead(
+          entryFilePath
+        );
+        const migratedEntryFile = this.entryService.migrate(prevEntryFile);
+        await this.entryService.update({
+          projectId,
+          collectionId,
+          ...migratedEntryFile
+        });
+        this.logService.info(`Upgraded ${objectType} "${entryFilePath}"`, {
+          previous: prevEntryFile,
+          migrated: migratedEntryFile
+        });
+        return;
+      }
+      default:
+        throw new Error(
+          `Trying to upgrade unsupported object file of type "${objectType}"`
+        );
+    }
   }
 };
 
 // src/service/UserService.ts
 var UserService = class {
+  logService;
   jsonFileService;
-  constructor(jsonFileService) {
+  constructor(logService, jsonFileService) {
+    this.logService = logService;
     this.jsonFileService = jsonFileService;
   }
   /**
@@ -2937,6 +3436,7 @@ var UserService = class {
     try {
       return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
     } catch (error) {
+      this.logService.info("No User found");
       return void 0;
     }
   }
@@ -2954,13 +3454,16 @@ var UserService = class {
     if (userFile.userType === UserTypeSchema.Enum.cloud) {
     }
     await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
+    this.logService.debug("Updated User");
     return userFile;
   }
 };
 
 // src/index.node.ts
 var ElekIoCore = class {
+  coreVersion;
   options;
+  logService;
   userService;
   gitService;
   jsonFileService;
@@ -2968,24 +3471,29 @@ var ElekIoCore = class {
   projectService;
   collectionService;
   entryService;
-  // private readonly sharedValueService: SharedValueService;
   constructor(props) {
+    this.coreVersion = version;
     const parsedProps = constructorElekIoCoreSchema.parse(props);
     const defaults = {
-      environment: "production",
-      version: "0.0.0",
+      log: {
+        level: "info"
+      },
       file: {
-        json: {
-          indentation: 2
-        }
+        cache: true
       }
     };
     this.options = Object.assign({}, defaults, parsedProps);
-    this.jsonFileService = new JsonFileService(this.options);
-    this.userService = new UserService(this.jsonFileService);
-    this.gitService = new GitService(this.options, this.userService);
+    this.logService = new LogService(this.options);
+    this.jsonFileService = new JsonFileService(this.options, this.logService);
+    this.userService = new UserService(this.logService, this.jsonFileService);
+    this.gitService = new GitService(
+      this.options,
+      this.logService,
+      this.userService
+    );
     this.assetService = new AssetService(
       this.options,
+      this.logService,
       this.jsonFileService,
       this.gitService
     );
@@ -2996,14 +3504,16 @@ var ElekIoCore = class {
     );
     this.entryService = new EntryService(
       this.options,
+      this.logService,
       this.jsonFileService,
       this.gitService,
       this.collectionService,
       this.assetService
-      // this.sharedValueService
     );
     this.projectService = new ProjectService(
+      this.coreVersion,
       this.options,
+      this.logService,
       this.jsonFileService,
       this.userService,
       this.gitService,
@@ -3011,18 +3521,19 @@ var ElekIoCore = class {
       this.collectionService,
       this.entryService
     );
-    if (this.options.environment !== "production") {
-      console.info(
-        `Initializing inside an "${this.options.environment}" environment`,
-        {
-          ...this.options
-        }
-      );
-    }
+    this.logService.info(`Initializing elek.io Core ${this.coreVersion}`, {
+      options: this.options
+    });
     Fs7.mkdirpSync(pathTo.projects);
     Fs7.mkdirpSync(pathTo.tmp);
     Fs7.emptyDirSync(pathTo.tmp);
   }
+  /**
+   * Exposes the logger
+   */
+  get logger() {
+    return this.logService;
+  }
   /**
    * Utility / helper functions
    */
@@ -3065,12 +3576,6 @@ var ElekIoCore = class {
   get entries() {
     return this.entryService;
   }
-  /**
-   * CRUD methods to work with Values
-   */
-  // public get sharedValues(): SharedValueService {
-  //   return this.sharedValueService;
-  // }
 };
 export {
   BooleanFieldDefinitionBaseSchema,
@@ -3087,7 +3592,6 @@ export {
   assetFileSchema,
   assetSchema,
   baseFileSchema,
-  baseFileWithLanguageSchema,
   baseUserSchema,
   cloneProjectSchema,
   cloudUserSchema,
@@ -3125,18 +3629,17 @@ export {
   entryFieldDefinitionSchema,
   entryFileSchema,
   entrySchema,
-  environmentSchema,
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
   getRemoteOriginUrlProjectSchema,
   getValueContentSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
-  gitCommitIconSchema,
   gitCommitSchema,
   gitInitOptionsSchema,
   gitLogOptionsSchema,
-  gitRepositoryPathSchema,
+  gitMergeOptionsSchema,
+  gitMessageSchema,
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
@@ -3148,8 +3651,11 @@ export {
   listGitTagsSchema,
   listProjectsSchema,
   localUserSchema,
+  logLevelSchema,
   numberFieldDefinitionSchema,
   objectTypeSchema,
+  outdatedProjectSchema,
+  projectBranchSchema,
   projectExportSchema,
   projectFileSchema,
   projectFolderSchema,
@@ -3167,15 +3673,13 @@ export {
   resolvedReferencedValueSchema,
   resolvedValueContentReferenceSchema,
   resolvedValueSchema,
+  saveAssetSchema,
   searchProjectSchema,
   serviceTypeSchema,
   setRemoteOriginUrlProjectSchema,
   setUserSchema,
   slug,
   stringFieldDefinitionSchema,
-  supportedAssetExtensionSchema,
-  supportedAssetMimeTypeSchema,
-  supportedAssetTypeSchema,
   supportedIconSchema,
   supportedLanguageSchema,
   switchBranchProjectSchema,
@@ -3204,7 +3708,6 @@ export {
   valueContentReferenceToAssetSchema,
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema,
-  valueContentReferenceWithLanguageBase,
   valueSchema,
   versionSchema
 };