@elek-io/core 0.9.0 → 0.10.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.10.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
@@ -108,6 +110,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 +132,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
    *
@@ -161,23 +168,108 @@ var fileReferenceSchema = z2.object({
   extension: supportedAssetExtensionSchema.optional()
 });
 
+// src/schema/gitSchema.ts
+import { z as z3 } from "zod";
+var gitRepositoryPathSchema = z3.string();
+var gitSignatureSchema = z3.object({
+  name: z3.string(),
+  email: z3.string()
+});
+var gitCommitSchema = z3.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: z3.string(),
+  message: z3.string(),
+  author: gitSignatureSchema,
+  datetime: z3.string().datetime(),
+  tag: z3.string().nullable()
+});
+var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
+  GitCommitIconNative2["INIT"] = ":tada:";
+  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
+  GitCommitIconNative2["UPDATE"] = ":wrench:";
+  GitCommitIconNative2["DELETE"] = ":heavy_minus_sign:";
+  return GitCommitIconNative2;
+})(GitCommitIconNative || {});
+var gitCommitIconSchema = z3.nativeEnum(GitCommitIconNative);
+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({
+  /**
+   * 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()
+});
+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()
+});
+
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
-  objectType: z3.literal(objectTypeSchema.Enum.asset).readonly(),
-  name: z3.string(),
-  description: z3.string(),
+  objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
+  name: z4.string(),
+  description: z4.string(),
   extension: supportedAssetExtensionSchema.readonly(),
   mimeType: supportedAssetMimeTypeSchema.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 +280,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 +304,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 +312,96 @@ 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 +412,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 +429,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 +458,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 +531,50 @@ 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),
+  allowedMimeTypes: z7.array(supportedAssetMimeTypeSchema).min(1),
+  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 +601,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 +617,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 +656,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 +679,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 +709,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,115 +725,34 @@ 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()
   })
 });
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
+  log: true,
+  file: true
+}).optional();
 
 // src/schema/gitTagSchema.ts
 import { z as z10 } from "zod";
@@ -774,7 +804,22 @@ var projectFileSchema = baseFileSchema.extend({
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
-var projectSchema = projectFileSchema.extend({});
+var projectSchema = projectFileSchema.extend({
+  /**
+   * Commit history of this Project
+   */
+  history: z11.array(gitCommitSchema),
+  /**
+   * Full commit history of this Project
+   * including all Assets, Collections, Entries and other files
+   */
+  fullHistory: z11.array(gitCommitSchema)
+});
+var outdatedProjectSchema = projectFileSchema.pick({
+  id: true,
+  name: true,
+  coreVersion: true
+});
 var projectExportSchema = projectSchema.extend({
   assets: z11.array(assetExportSchema),
   collections: z11.array(collectionExportSchema)
@@ -788,7 +833,8 @@ var createProjectSchema = projectSchema.pick({
   settings: true
 });
 var readProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+  id: uuidSchema.readonly(),
+  commitHash: z11.string().optional().readonly()
 });
 var updateProjectSchema = projectSchema.pick({
   id: true,
@@ -801,7 +847,11 @@ var updateProjectSchema = projectSchema.pick({
   settings: true
 });
 var upgradeProjectSchema = z11.object({
-  id: uuidSchema.readonly()
+  id: uuidSchema.readonly(),
+  /**
+   * Force the upgrade even if the Project is up-to-date
+   */
+  force: z11.boolean().optional()
 });
 var deleteProjectSchema = readProjectSchema.extend({});
 var projectUpgradeSchema = z11.object({
@@ -886,7 +936,6 @@ var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
   window: z13.object({
-    displayId: z13.number(),
     width: z13.number(),
     height: z13.number(),
     position: z13.object({
@@ -959,7 +1008,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);
@@ -1011,6 +1060,9 @@ 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) {
@@ -1217,10 +1269,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;
   }
@@ -1237,6 +1292,7 @@ var AssetService = class extends AbstractCrudService {
     const assetFilePath = pathTo.assetFile(props.projectId, id);
     const assetFile = {
       ...props,
+      name: slug(props.name),
       objectType: "asset",
       id,
       created: datetime(),
@@ -1262,14 +1318,48 @@ var AssetService = class extends AbstractCrudService {
   }
   /**
    * 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
@@ -1284,6 +1374,7 @@ var AssetService = class extends AbstractCrudService {
     const assetFile = {
       ...prevAssetFile,
       ...props,
+      name: slug(props.name),
       updated: datetime()
     };
     if (props.newFilePath) {
@@ -1303,6 +1394,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;
@@ -1378,15 +1470,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;
   }
@@ -1414,6 +1506,12 @@ var AssetService = class extends AbstractCrudService {
     });
     return result;
   }
+  /**
+   * Migrates an potentially outdated Asset file to the current schema
+   */
+  migrate(potentiallyOutdatedAssetFile) {
+    return assetFileSchema.parse(potentiallyOutdatedAssetFile);
+  }
 };
 
 // src/service/CollectionService.ts
@@ -1454,18 +1552,33 @@ var CollectionService = class extends AbstractCrudService {
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
-    return collectionFile;
+    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
@@ -1494,7 +1607,7 @@ var CollectionService = class extends AbstractCrudService {
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
-    return collectionFile;
+    return this.toCollection(props.projectId, collectionFile);
   }
   /**
    * Deletes given Collection (folder), including it's items
@@ -1550,18 +1663,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;
@@ -1590,11 +1727,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,
@@ -1610,19 +1747,30 @@ var EntryService = class extends AbstractCrudService {
     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
@@ -1649,11 +1797,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,
@@ -1723,6 +1871,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
    */
@@ -1751,14 +1905,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);
       }
     });
   }
@@ -1828,16 +1984,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 {
@@ -1854,11 +2014,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) {
@@ -1941,7 +2100,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) => {
@@ -1992,16 +2151,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();
@@ -2027,7 +2188,6 @@ var GitService = class {
     }
     await this.git(path, args);
     await this.setLocalConfig(path);
-    await this.installLfs(path);
   }
   /**
    * Clone a repository into a directory
@@ -2064,9 +2224,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
@@ -2078,7 +2254,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("* ", "");
@@ -2140,7 +2316,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;
@@ -2167,7 +2343,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);
     },
     /**
@@ -2194,7 +2370,7 @@ 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);
     }
   };
@@ -2315,11 +2491,12 @@ 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) => {
@@ -2337,6 +2514,27 @@ var GitService = class {
     });
     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) {
@@ -2376,16 +2574,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
    *
@@ -2423,31 +2611,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;
   }
 };
 
@@ -2455,8 +2649,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
@@ -2473,7 +2669,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;
   }
   /**
@@ -2484,18 +2681,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
    *
@@ -2513,31 +2735,90 @@ 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.cli()
+        })
+      ]
+    });
+    rotatingFileTransport.on("rotate", (oldFilename, newFilename) => {
+      this.logger.info(
+        `Rotated log file from ${oldFilename} to ${newFilename}`
+      );
+    });
+  }
+  debug(message, ...meta) {
+    return this.logger.debug(message, ...meta);
+  }
+  info(message, ...meta) {
+    return this.logger.info(message, ...meta);
+  }
+  warn(message, ...meta) {
+    return this.logger.warn(message, ...meta);
+  }
+  error(message, ...meta) {
+    return 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";
 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;
@@ -2569,8 +2850,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"
     };
@@ -2599,9 +2879,7 @@ var ProjectService = class extends AbstractCrudService {
       });
       throw error;
     }
-    return await this.toProject({
-      projectFile
-    });
+    return await this.toProject(projectFile);
   }
   /**
    * Clones a Project by URL
@@ -2609,10 +2887,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);
@@ -2624,22 +2902,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
@@ -2653,6 +2942,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,
@@ -2664,82 +2954,97 @@ 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
-    });
+    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 prevProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
+    if (Semver.gt(prevProjectFile.coreVersion, this.coreVersion)) {
+      throw new ProjectUpgradeError(
+        `The Projects Core version "${prevProjectFile.coreVersion}" is higher than the current Core version "${this.coreVersion}".`
       );
     }
-    if (Semver.eq(project.coreVersion, this.options.version)) {
-      return;
+    if (Semver.eq(prevProjectFile.coreVersion, this.coreVersion) && props.force !== true) {
+      throw new ProjectUpgradeError(
+        `The Projects Core version "${prevProjectFile.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 ${prevProjectFile.coreVersion} to ${this.coreVersion}`
+    );
+    const failsafeTag = await this.gitService.tags.create({
+      path: projectPath,
+      message: `Attempting to upgrade Project from Core version ${prevProjectFile.coreVersion} to ${this.coreVersion}`
     });
-    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(prevProjectFile);
+      await this.update(migratedProjectFile);
+      this.logService.info(`Upgraded project "${projectFilePath}"`, {
+        previous: prevProjectFile,
+        migrated: migratedProjectFile
+      });
+      await this.gitService.tags.create({
         path: projectPath,
-        message: `Attempting to upgrade Project to Core version "${upgrade.to}"`
+        message: `Upgraded Project to Core version "${this.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.tags.delete({
+        path: projectPath,
+        id: failsafeTag.id
+      });
+    } catch (error) {
+      await this.gitService.reset(projectPath, "hard", failsafeTag.id);
+      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) => {
@@ -2761,7 +3066,12 @@ var ProjectService = class extends AbstractCrudService {
     getOriginUrl: async (props) => {
       getRemoteOriginUrlProjectSchema.parse(props);
       const projectPath = pathTo.project(props.id);
-      return await this.gitService.remotes.getOriginUrl(projectPath);
+      const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+      if (!hasOrigin) {
+        return null;
+      } else {
+        return await this.gitService.remotes.getOriginUrl(projectPath);
+      }
     },
     setOriginUrl: async (props) => {
       setRemoteOriginUrlProjectSchema.parse(props);
@@ -2818,6 +3128,27 @@ var ProjectService = class extends AbstractCrudService {
     deleteProjectSchema.parse(props);
     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);
@@ -2880,11 +3211,25 @@ 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 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,
+      history,
+      fullHistory
     };
   }
   /**
@@ -2896,8 +3241,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"), "");
       })
     );
   }
@@ -2921,14 +3266,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;
   }
   /**
@@ -2938,6 +3349,7 @@ var UserService = class {
     try {
       return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
     } catch (error) {
+      this.logService.info("No User found");
       return void 0;
     }
   }
@@ -2955,13 +3367,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;
@@ -2969,24 +3384,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
     );
@@ -2997,14 +3417,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,
@@ -3012,18 +3434,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
    */
@@ -3066,12 +3489,6 @@ var ElekIoCore = class {
   get entries() {
     return this.entryService;
   }
-  /**
-   * CRUD methods to work with Values
-   */
-  // public get sharedValues(): SharedValueService {
-  //   return this.sharedValueService;
-  // }
 };
 export {
   BooleanFieldDefinitionBaseSchema,
@@ -3126,7 +3543,6 @@ export {
   entryFieldDefinitionSchema,
   entryFileSchema,
   entrySchema,
-  environmentSchema,
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
@@ -3149,8 +3565,10 @@ export {
   listGitTagsSchema,
   listProjectsSchema,
   localUserSchema,
+  logLevelSchema,
   numberFieldDefinitionSchema,
   objectTypeSchema,
+  outdatedProjectSchema,
   projectExportSchema,
   projectFileSchema,
   projectFolderSchema,
@@ -3168,6 +3586,7 @@ export {
   resolvedReferencedValueSchema,
   resolvedValueContentReferenceSchema,
   resolvedValueSchema,
+  saveAssetSchema,
   searchProjectSchema,
   serviceTypeSchema,
   setRemoteOriginUrlProjectSchema,