@elek-io/core 0.14.3 → 0.15.0

package/dist/node/index.node.js

@@ -10,7 +10,7 @@ import Fs7 from "fs-extra";
 // package.json
 var package_default = {
   name: "@elek-io/core",
-  version: "0.14.3",
+  version: "0.15.0",
   description: "Handles core functionality of elek.io Projects like file IO and version control.",
   homepage: "https://elek.io",
   repository: "https://github.com/elek-io/core",
@@ -37,7 +37,10 @@ var package_default = {
     }
   },
   scripts: {
-    lint: "tsc",
+    lint: "eslint",
+    "check-types": "tsc --noEmit",
+    "check-format": "prettier --check . || exit 0",
+    format: "prettier --write .",
     dev: "vitest",
     test: "vitest run",
     coverage: "vitest run --coverage",
@@ -45,32 +48,38 @@ var package_default = {
     release: "changeset publish"
   },
   dependencies: {
-    "@hono/node-server": "1.15.0",
+    "@hono/node-server": "1.19.5",
     "@hono/swagger-ui": "0.5.2",
-    "@hono/zod-openapi": "0.19.9",
-    "@sindresorhus/slugify": "2.2.1",
-    "fs-extra": "11.3.0",
-    hono: "4.8.4",
-    mime: "4.0.7",
-    "p-queue": "8.1.0",
+    "@hono/zod-openapi": "1.1.3",
+    "@sindresorhus/slugify": "3.0.0",
+    "fs-extra": "11.3.2",
+    hono: "4.9.9",
+    mime: "4.1.0",
+    "p-queue": "8.1.1",
     semver: "7.7.2",
-    uuid: "11.1.0",
-    winston: "3.17.0",
+    uuid: "13.0.0",
+    winston: "3.18.2",
     "winston-daily-rotate-file": "5.0.0",
-    zod: "3.25.74"
+    zod: "4.1.11"
   },
   devDependencies: {
-    "@changesets/cli": "2.29.5",
-    "@faker-js/faker": "9.9.0",
+    "@changesets/cli": "2.29.7",
+    "@eslint/js": "9.36.0",
+    "@faker-js/faker": "10.0.0",
     "@tsconfig/node22": "22.0.2",
-    "@tsconfig/strictest": "2.0.5",
+    "@tsconfig/strictest": "2.0.6",
     "@types/fs-extra": "11.0.4",
-    "@types/node": "22.16.0",
-    "@types/semver": "7.7.0",
-    "@types/uuid": "10.0.0",
+    "@types/node": "22.13.14",
+    "@types/semver": "7.7.1",
     "@vitest/coverage-v8": "3.2.4",
+    eslint: "9.36.0",
+    "eslint-config-prettier": "10.1.8",
+    globals: "16.4.0",
+    jiti: "2.6.0",
+    prettier: "3.6.2",
     tsup: "8.5.0",
-    typescript: "5.8.3",
+    typescript: "5.9.2",
+    "typescript-eslint": "8.45.0",
     vitest: "3.2.4"
   },
   peerDependencies: {
@@ -110,7 +119,7 @@ var LoggerMiddleware = class {
 };
 
 // src/api/v1/asset.ts
-import { createRoute, OpenAPIHono, z as z13 } from "@hono/zod-openapi";
+import { createRoute, OpenAPIHono, z as z14 } from "@hono/zod-openapi";
 
 // src/schema/assetSchema.ts
 import { z as z4 } from "@hono/zod-openapi";
@@ -181,21 +190,25 @@ var objectTypeSchema = z.enum([
 ]);
 var logLevelSchema = z.enum(["error", "warn", "info", "debug"]);
 var versionSchema = z.string();
-var uuidSchema = z.string().uuid("shared.invalidUuid");
-var translatableStringSchema = z.record(
+var uuidSchema = z.uuid("shared.invalidUuid");
+var translatableStringSchema = z.partialRecord(
   supportedLanguageSchema,
   z.string().trim().min(1, "shared.translatableStringRequired")
 );
-var translatableNumberSchema = z.record(
+var translatableNumberSchema = z.partialRecord(
   supportedLanguageSchema,
-  z.number({ required_error: "shared.translatableNumberRequired" })
+  z.number({
+    error: (error) => error.input === void 0 ? "shared.translatableNumberRequired" : "shared.translatableNumberNotANumber"
+  })
 );
-var translatableBooleanSchema = z.record(
+var translatableBooleanSchema = z.partialRecord(
   supportedLanguageSchema,
-  z.boolean({ required_error: "shared.translatableBooleanRequired" })
+  z.boolean({
+    error: (error) => error.input === void 0 ? "shared.translatableBooleanRequired" : "shared.translatableBooleanNotABoolean"
+  })
 );
 function translatableArrayOf(schema) {
-  return z.record(supportedLanguageSchema, z.array(schema));
+  return z.partialRecord(supportedLanguageSchema, z.array(schema));
 }
 
 // src/schema/fileSchema.ts
@@ -345,7 +358,7 @@ var countGitTagsSchema = z3.object({
 
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
-  objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
+  objectType: z4.literal(objectTypeSchema.enum.asset).readonly(),
   name: z4.string(),
   description: z4.string(),
   extension: z4.string().readonly(),
@@ -426,13 +439,13 @@ var valueContentReferenceBase = z5.object({
   id: uuidSchema
 });
 var valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.asset)
+  objectType: z5.literal(objectTypeSchema.enum.asset)
 });
 var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.collection)
+  objectType: z5.literal(objectTypeSchema.enum.collection)
 });
 var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: z5.literal(objectTypeSchema.Enum.entry)
+  objectType: z5.literal(objectTypeSchema.enum.entry)
 });
 var valueContentReferenceSchema = z5.union([
   valueContentReferenceToAssetSchema,
@@ -441,19 +454,19 @@ var valueContentReferenceSchema = z5.union([
   // valueContentReferenceToSharedValueSchema,
 ]);
 var directValueBaseSchema = z5.object({
-  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
+  objectType: z5.literal(objectTypeSchema.enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.string).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.string).readonly(),
   content: translatableStringSchema
 });
 var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.number).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.number).readonly(),
   content: translatableNumberSchema
 });
 var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: z5.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.boolean).readonly(),
   content: translatableBooleanSchema
 });
 var directValueSchema = z5.union([
@@ -462,16 +475,16 @@ var directValueSchema = z5.union([
   directBooleanValueSchema
 ]);
 var referencedValueSchema = z5.object({
-  objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
+  objectType: z5.literal(objectTypeSchema.enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly(),
-  valueType: z5.literal(ValueTypeSchema.Enum.reference).readonly(),
+  valueType: z5.literal(ValueTypeSchema.enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
 var valueSchema = z5.union([directValueSchema, referencedValueSchema]);
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
-  objectType: z6.literal(objectTypeSchema.Enum.entry).readonly(),
+  objectType: z6.literal(objectTypeSchema.enum.entry).readonly(),
   values: z6.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
@@ -520,7 +533,7 @@ var FieldTypeSchema = z7.enum([
   "email",
   // 'password', @todo maybe if there is a usecase
   "url",
-  "ip",
+  "ipv4",
   "date",
   "time",
   "datetime",
@@ -539,7 +552,7 @@ var FieldWidthSchema = z7.enum(["12", "6", "4", "3"]);
 var FieldDefinitionBaseSchema = z7.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
-  description: translatableStringSchema,
+  description: translatableStringSchema.nullable(),
   isRequired: z7.boolean(),
   isDisabled: z7.boolean(),
   isUnique: z7.boolean(),
@@ -547,60 +560,62 @@ var FieldDefinitionBaseSchema = z7.object({
 });
 var StringFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z7.literal(ValueTypeSchema.Enum.string),
+    valueType: z7.literal(ValueTypeSchema.enum.string),
     defaultValue: z7.string().nullable()
   }
 );
 var textFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.text),
+    fieldType: z7.literal(FieldTypeSchema.enum.text),
     min: z7.number().nullable(),
     max: z7.number().nullable()
   }
 );
 var textareaFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.textarea),
+  fieldType: z7.literal(FieldTypeSchema.enum.textarea),
   min: z7.number().nullable(),
   max: z7.number().nullable()
 });
 var emailFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.email),
-  defaultValue: z7.string().email().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.email),
+  defaultValue: z7.email().nullable()
 });
 var urlFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.url),
-  defaultValue: z7.string().url().nullable()
-});
-var ipFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.ip),
-  defaultValue: z7.string().ip().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.url),
+  defaultValue: z7.url().nullable()
 });
+var ipv4FieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
+  {
+    fieldType: z7.literal(FieldTypeSchema.enum.ipv4),
+    defaultValue: z7.ipv4().nullable()
+  }
+);
 var dateFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.date),
-    defaultValue: z7.string().date().nullable()
+    fieldType: z7.literal(FieldTypeSchema.enum.date),
+    defaultValue: z7.iso.date().nullable()
   }
 );
 var timeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend(
   {
-    fieldType: z7.literal(FieldTypeSchema.Enum.time),
-    defaultValue: z7.string().time().nullable()
+    fieldType: z7.literal(FieldTypeSchema.enum.time),
+    defaultValue: z7.iso.time().nullable()
   }
 );
 var datetimeFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.datetime),
-  defaultValue: z7.string().datetime().nullable()
+  fieldType: z7.literal(FieldTypeSchema.enum.datetime),
+  defaultValue: z7.iso.datetime().nullable()
 });
 var telephoneFieldDefinitionSchema = StringFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.telephone)
-  // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
+  fieldType: z7.literal(FieldTypeSchema.enum.telephone),
+  defaultValue: z7.e164().nullable()
 });
 var stringFieldDefinitionSchema = z7.union([
   textFieldDefinitionSchema,
   textareaFieldDefinitionSchema,
   emailFieldDefinitionSchema,
   urlFieldDefinitionSchema,
-  ipFieldDefinitionSchema,
+  ipv4FieldDefinitionSchema,
   dateFieldDefinitionSchema,
   timeFieldDefinitionSchema,
   datetimeFieldDefinitionSchema,
@@ -608,7 +623,7 @@ var stringFieldDefinitionSchema = z7.union([
 ]);
 var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   {
-    valueType: z7.literal(ValueTypeSchema.Enum.number),
+    valueType: z7.literal(ValueTypeSchema.enum.number),
     min: z7.number().nullable(),
     max: z7.number().nullable(),
     isUnique: z7.literal(false),
@@ -616,10 +631,10 @@ var NumberFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend(
   }
 );
 var numberFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.number)
+  fieldType: z7.literal(FieldTypeSchema.enum.number)
 });
 var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
-  fieldType: z7.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: z7.literal(true),
   min: z7.number(),
@@ -627,25 +642,25 @@ var rangeFieldDefinitionSchema = NumberFieldDefinitionBaseSchema.extend({
   defaultValue: z7.number()
 });
 var BooleanFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z7.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: z7.literal(true),
   defaultValue: z7.boolean(),
   isUnique: z7.literal(false)
 });
 var toggleFieldDefinitionSchema = BooleanFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.toggle)
+  fieldType: z7.literal(FieldTypeSchema.enum.toggle)
 });
 var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
-  valueType: z7.literal(ValueTypeSchema.Enum.reference)
+  valueType: z7.literal(ValueTypeSchema.enum.reference)
 });
 var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.asset),
+  fieldType: z7.literal(FieldTypeSchema.enum.asset),
   min: z7.number().nullable(),
   max: z7.number().nullable()
 });
 var entryFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
-  fieldType: z7.literal(FieldTypeSchema.Enum.entry),
+  fieldType: z7.literal(FieldTypeSchema.enum.entry),
   ofCollections: z7.array(uuidSchema),
   min: z7.number().nullable(),
   max: z7.number().nullable()
@@ -659,103 +674,10 @@ var fieldDefinitionSchema = z7.union([
   entryFieldDefinitionSchema
   // sharedValueDefinitionSchema,
 ]);
-function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
-  switch (fieldDefinition.valueType) {
-    case ValueTypeSchema.Enum.boolean:
-      return getBooleanValueContentSchema();
-    case ValueTypeSchema.Enum.number:
-      return getNumberValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.string:
-      return getStringValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.Enum.reference:
-      return getReferenceValueContentSchema(fieldDefinition);
-    default:
-      throw new Error(
-        // @ts-expect-error
-        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
-      );
-  }
-}
-function getBooleanValueContentSchema() {
-  return z7.boolean();
-}
-function getNumberValueContentSchema(definition) {
-  let schema = z7.number();
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema;
-}
-function getStringValueContentSchema(definition) {
-  let schema = z7.string().trim();
-  if ("min" in definition && definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if ("max" in definition && definition.max) {
-    schema = schema.max(definition.max);
-  }
-  switch (definition.fieldType) {
-    case FieldTypeSchema.Enum.email:
-      schema = schema.email();
-      break;
-    case FieldTypeSchema.Enum.url:
-      schema = schema.url();
-      break;
-    case FieldTypeSchema.Enum.ip:
-      schema = schema.ip();
-      break;
-    case FieldTypeSchema.Enum.date:
-      schema = schema.date();
-      break;
-    case FieldTypeSchema.Enum.time:
-      schema = schema.time();
-      break;
-    case FieldTypeSchema.Enum.datetime:
-      schema = schema.datetime();
-      break;
-    case FieldTypeSchema.Enum.telephone:
-      break;
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema.min(1, "shared.stringValueRequired");
-}
-function getReferenceValueContentSchema(definition) {
-  let schema;
-  switch (definition.fieldType) {
-    case FieldTypeSchema.Enum.asset:
-      {
-        schema = z7.array(valueContentReferenceToAssetSchema);
-      }
-      break;
-    case FieldTypeSchema.Enum.entry:
-      {
-        schema = z7.array(valueContentReferenceToEntrySchema);
-      }
-      break;
-  }
-  if (definition.isRequired) {
-    schema = schema.min(1, "shared.referenceRequired");
-  }
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  return schema;
-}
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: z8.literal(objectTypeSchema.Enum.collection).readonly(),
+  objectType: z8.literal(objectTypeSchema.enum.collection).readonly(),
   name: z8.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
@@ -850,7 +772,7 @@ var projectFolderSchema = z10.enum([
 ]);
 var projectBranchSchema = z10.enum(["production", "work"]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: z10.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: z10.literal(objectTypeSchema.enum.project).readonly(),
   coreVersion: versionSchema,
   name: z10.string().trim().min(1, "shared.projectNameRequired"),
   description: z10.string().trim().min(1, "shared.projectDescriptionRequired"),
@@ -918,7 +840,10 @@ var projectUpgradeSchema = z10.object({
   /**
    * Function that will be executed in the process of upgrading a Project
    */
-  run: z10.function().args(projectFileSchema).returns(z10.promise(z10.void()))
+  run: z10.function({
+    input: [projectFileSchema],
+    output: z10.promise(z10.void())
+  })
 });
 var cloneProjectSchema = z10.object({
   url: z10.string()
@@ -954,9 +879,182 @@ var searchProjectSchema = z10.object({
   type: z10.array(objectTypeSchema).optional()
 });
 
+// src/schema/schemaFromFieldDefinition.ts
+import z11 from "zod";
+function getBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.boolean();
+}
+function getNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = z11.number();
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema;
+}
+function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = null;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.email:
+      schema = z11.email();
+      break;
+    case FieldTypeSchema.enum.url:
+      schema = z11.url();
+      break;
+    case FieldTypeSchema.enum.ipv4:
+      schema = z11.ipv4();
+      break;
+    case FieldTypeSchema.enum.date:
+      schema = z11.iso.date();
+      break;
+    case FieldTypeSchema.enum.time:
+      schema = z11.iso.time();
+      break;
+    case FieldTypeSchema.enum.datetime:
+      schema = z11.iso.datetime();
+      break;
+    case FieldTypeSchema.enum.telephone:
+      schema = z11.e164();
+      break;
+    case FieldTypeSchema.enum.text:
+    case FieldTypeSchema.enum.textarea:
+      schema = z11.string().trim();
+      break;
+  }
+  if ("min" in fieldDefinition && fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if ("max" in fieldDefinition && fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema.min(1, "shared.stringValueRequired");
+}
+function getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.asset:
+      {
+        schema = z11.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case FieldTypeSchema.enum.entry:
+      {
+        schema = z11.array(valueContentReferenceToEntrySchema);
+      }
+      break;
+  }
+  if (fieldDefinition.isRequired) {
+    schema = schema.min(1, "shared.referenceRequired");
+  }
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  return schema;
+}
+function getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getStringValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getNumberValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getBooleanValueContentSchemaFromFieldDefinition()
+  );
+}
+function getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getValueSchemaFromFieldDefinition(fieldDefinition) {
+  switch (fieldDefinition.valueType) {
+    case ValueTypeSchema.enum.boolean:
+      return directBooleanValueSchema.extend({
+        content: getTranslatableBooleanValueContentSchemaFromFieldDefinition()
+      });
+    case ValueTypeSchema.enum.number:
+      return directNumberValueSchema.extend({
+        content: getTranslatableNumberValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.string:
+      return directStringValueSchema.extend({
+        content: getTranslatableStringValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.reference:
+      return referencedValueSchema.extend({
+        content: getTranslatableReferenceValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    default:
+      throw new Error(
+        // @ts-expect-error Code cannot be reached, but if we add a new ValueType and forget to update this function, we want to be notified about it
+        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
+      );
+  }
+}
+function getCreateEntrySchemaFromFieldDefinitions(fieldDefinitions, values) {
+  const schema = {
+    ...createEntrySchema,
+    values: values.map((value) => {
+      const fieldDefinition = fieldDefinitions.find(
+        (fieldDefinition2) => fieldDefinition2.id === value.fieldDefinitionId
+      );
+      if (!fieldDefinition) {
+        throw new Error(
+          `Field definition with ID "${value.fieldDefinitionId}" not found`
+        );
+      }
+      return getValueSchemaFromFieldDefinition(fieldDefinition);
+    })
+  };
+  return schema;
+}
+function getUpdateEntrySchemaFromFieldDefinitions(fieldDefinitions, values) {
+  const schema = {
+    ...updateEntrySchema,
+    values: values.map((value) => {
+      const fieldDefinition = fieldDefinitions.find(
+        (fieldDefinition2) => fieldDefinition2.id === value.fieldDefinitionId
+      );
+      if (!fieldDefinition) {
+        throw new Error(
+          `Field definition with ID "${value.fieldDefinitionId}" not found`
+        );
+      }
+      return getValueSchemaFromFieldDefinition(fieldDefinition);
+    })
+  };
+  return schema;
+}
+
 // src/schema/serviceSchema.ts
-import { z as z11 } from "zod";
-var serviceTypeSchema = z11.enum([
+import { z as z12 } from "zod";
+var serviceTypeSchema = z12.enum([
   "Git",
   "GitTag",
   "User",
@@ -969,17 +1067,17 @@ var serviceTypeSchema = z11.enum([
   "Value"
 ]);
 function paginatedListOf(schema) {
-  return z11.object({
-    total: z11.number(),
-    limit: z11.number(),
-    offset: z11.number(),
-    list: z11.array(schema)
+  return z12.object({
+    total: z12.number(),
+    limit: z12.number(),
+    offset: z12.number(),
+    list: z12.array(schema)
   });
 }
-var listSchema = z11.object({
+var listSchema = z12.object({
   projectId: uuidSchema,
-  limit: z11.number().optional(),
-  offset: z11.number().optional()
+  limit: z12.number().optional(),
+  offset: z12.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -989,35 +1087,35 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z11.object({
-  path: z11.string()
+var listGitTagsSchema = z12.object({
+  path: z12.string()
 });
 
 // src/schema/userSchema.ts
-import z12 from "zod";
-var UserTypeSchema = z12.enum(["local", "cloud"]);
+import z13 from "zod";
+var UserTypeSchema = z13.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
-  localApi: z12.object({
+  localApi: z13.object({
     /**
      * If set to true the local API is started whenever Core is initialized
      */
-    isEnabled: z12.boolean(),
+    isEnabled: z13.boolean(),
     /**
      * The port the local API uses
      */
-    port: z12.number()
+    port: z13.number()
   })
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.local)
+  userType: z13.literal(UserTypeSchema.enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.Enum.cloud),
+  userType: z13.literal(UserTypeSchema.enum.cloud),
   id: uuidSchema
 });
-var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
+var userFileSchema = z13.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
@@ -1063,7 +1161,7 @@ var listAssetsRoute = createRoute({
   path: "/projects/{projectId}/assets",
   operationId: "listAssets",
   request: {
-    params: z13.object({
+    params: z14.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1071,12 +1169,12 @@ var listAssetsRoute = createRoute({
         }
       })
     }),
-    query: z13.object({
-      limit: z13.string().pipe(z13.coerce.number()).optional().openapi({
+    query: z14.object({
+      limit: z14.string().pipe(z14.coerce.number()).optional().openapi({
         default: "15",
         description: "The maximum number of items to return"
       }),
-      offset: z13.string().pipe(z13.coerce.number()).optional().openapi({
+      offset: z14.string().pipe(z14.coerce.number()).optional().openapi({
         default: "0",
         description: "The number of items to skip before starting to collect the result set"
       })
@@ -1100,7 +1198,7 @@ var countAssetsRoute = createRoute({
   path: "/projects/{projectId}/assets/count",
   operationId: "countAssets",
   request: {
-    params: z13.object({
+    params: z14.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1113,7 +1211,7 @@ var countAssetsRoute = createRoute({
     200: {
       content: {
         "application/json": {
-          schema: z13.number()
+          schema: z14.number()
         }
       },
       description: "The number of Assets of the given Project"
@@ -1127,7 +1225,7 @@ var readAssetRoute = createRoute({
   path: "/projects/{projectId}/assets/{assetId}",
   operationId: "readAsset",
   request: {
-    params: z13.object({
+    params: z14.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1158,7 +1256,7 @@ var readAssetRoute = createRoute({
 });
 
 // src/api/v1/collection.ts
-import { createRoute as createRoute2, OpenAPIHono as OpenAPIHono2, z as z14 } from "@hono/zod-openapi";
+import { createRoute as createRoute2, OpenAPIHono as OpenAPIHono2, z as z15 } from "@hono/zod-openapi";
 var CollectionApiV1 = class {
   api;
   collectionService;
@@ -1200,7 +1298,7 @@ var listCollectionsRoute = createRoute2({
   path: "/projects/{projectId}/collections",
   operationId: "listCollections",
   request: {
-    params: z14.object({
+    params: z15.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1208,12 +1306,12 @@ var listCollectionsRoute = createRoute2({
         }
       })
     }),
-    query: z14.object({
-      limit: z14.string().pipe(z14.coerce.number()).optional().openapi({
+    query: z15.object({
+      limit: z15.string().pipe(z15.coerce.number()).optional().openapi({
         default: "15",
         description: "The maximum number of items to return"
       }),
-      offset: z14.string().pipe(z14.coerce.number()).optional().openapi({
+      offset: z15.string().pipe(z15.coerce.number()).optional().openapi({
         default: "0",
         description: "The number of items to skip before starting to collect the result set"
       })
@@ -1237,7 +1335,7 @@ var countCollectionsRoute = createRoute2({
   path: "/projects/{projectId}/collections/count",
   operationId: "countCollections",
   request: {
-    params: z14.object({
+    params: z15.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1250,7 +1348,7 @@ var countCollectionsRoute = createRoute2({
     200: {
       content: {
         "application/json": {
-          schema: z14.number()
+          schema: z15.number()
         }
       },
       description: "The number of Collections of the given Project"
@@ -1264,7 +1362,7 @@ var readCollectionRoute = createRoute2({
   path: "/projects/{projectId}/collections/{collectionId}",
   operationId: "readCollection",
   request: {
-    params: z14.object({
+    params: z15.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1295,7 +1393,7 @@ var readCollectionRoute = createRoute2({
 });
 
 // src/api/v1/entry.ts
-import { createRoute as createRoute3, OpenAPIHono as OpenAPIHono3, z as z15 } from "@hono/zod-openapi";
+import { createRoute as createRoute3, OpenAPIHono as OpenAPIHono3, z as z16 } from "@hono/zod-openapi";
 var EntryApiV1 = class {
   api;
   entryService;
@@ -1339,7 +1437,7 @@ var listEntriesRoute = createRoute3({
   path: "/projects/{projectId}/collections/{collectionId}/entries",
   operationId: "listEntries",
   request: {
-    params: z15.object({
+    params: z16.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1353,12 +1451,12 @@ var listEntriesRoute = createRoute3({
         }
       })
     }),
-    query: z15.object({
-      limit: z15.string().pipe(z15.coerce.number()).optional().openapi({
+    query: z16.object({
+      limit: z16.string().pipe(z16.coerce.number()).optional().openapi({
         default: "15",
         description: "The maximum number of items to return"
       }),
-      offset: z15.string().pipe(z15.coerce.number()).optional().openapi({
+      offset: z16.string().pipe(z16.coerce.number()).optional().openapi({
         default: "0",
         description: "The number of items to skip before starting to collect the result set"
       })
@@ -1382,7 +1480,7 @@ var countEntriesRoute = createRoute3({
   path: "/projects/{projectId}/collections/{collectionId}/entries/count",
   operationId: "countEntries",
   request: {
-    params: z15.object({
+    params: z16.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1401,7 +1499,7 @@ var countEntriesRoute = createRoute3({
     200: {
       content: {
         "application/json": {
-          schema: z15.number()
+          schema: z16.number()
         }
       },
       description: "The number of Entries of the given Project"
@@ -1415,7 +1513,7 @@ var readEntryRoute = createRoute3({
   path: "/projects/{projectId}/collections/{collectionId}/entries/{entryId}",
   operationId: "readCollection",
   request: {
-    params: z15.object({
+    params: z16.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1452,7 +1550,7 @@ var readEntryRoute = createRoute3({
 });
 
 // src/api/v1/project.ts
-import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4, z as z16 } from "@hono/zod-openapi";
+import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4, z as z17 } from "@hono/zod-openapi";
 var ProjectApiV1 = class {
   api;
   projectService;
@@ -1485,12 +1583,12 @@ var listProjectsRoute = createRoute4({
   path: "/projects",
   operationId: "listProjects",
   request: {
-    query: z16.object({
-      limit: z16.string().pipe(z16.coerce.number()).optional().openapi({
+    query: z17.object({
+      limit: z17.string().pipe(z17.coerce.number()).optional().openapi({
         default: "15",
         description: "The maximum number of items to return"
       }),
-      offset: z16.string().pipe(z16.coerce.number()).optional().openapi({
+      offset: z17.string().pipe(z17.coerce.number()).optional().openapi({
         default: "0",
         description: "The number of items to skip before starting to collect the result set"
       })
@@ -1517,7 +1615,7 @@ var countProjectsRoute = createRoute4({
     200: {
       content: {
         "application/json": {
-          schema: z16.number()
+          schema: z17.number()
         }
       },
       description: "The number of Projects you have acces to"
@@ -1531,7 +1629,7 @@ var readProjectRoute = createRoute4({
   path: "/projects/{projectId}",
   operationId: "readProject",
   request: {
-    params: z16.object({
+    params: z17.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1730,18 +1828,18 @@ var pathTo = {
     return Path.join(pathTo.project(projectId), "project.json");
   },
   // projectLogs: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
+  //   return Path.join(pathTo.project(projectId), projectFolderSchema.enum.logs);
   // },
   // public: (projectId: string): string => {
   //   return Path.join(pathTo.project(projectId), 'public');
   // },
   lfs: (projectId) => {
-    return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
+    return Path.join(pathTo.project(projectId), projectFolderSchema.enum.lfs);
   },
   collections: (projectId) => {
     return Path.join(
       pathTo.project(projectId),
-      projectFolderSchema.Enum.collections
+      projectFolderSchema.enum.collections
     );
   },
   collection: (projectId, id) => {
@@ -1765,7 +1863,7 @@ var pathTo = {
   assets: (projectId) => {
     return Path.join(
       pathTo.project(projectId),
-      projectFolderSchema.Enum.assets
+      projectFolderSchema.enum.assets
     );
   },
   assetFile: (projectId, id) => {
@@ -1833,12 +1931,14 @@ async function files(path, extension) {
 var AbstractCrudService = class {
   type;
   options;
+  logService;
   /**
    * Do not instantiate directly as this is an abstract class
    */
-  constructor(type, options) {
+  constructor(type, options, logService) {
     this.type = type;
     this.options = options;
+    this.logService = logService;
   }
   /**
    * Returns a list of all file references of given project and type
@@ -1849,20 +1949,20 @@ var AbstractCrudService = class {
    */
   async listReferences(type, projectId, collectionId) {
     switch (type) {
-      case objectTypeSchema.Enum.asset:
+      case objectTypeSchema.enum.asset:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
       // LFS folder is correct, since we want the extension of the file itself, not the AssetFile (.json)
-      case objectTypeSchema.Enum.project:
+      case objectTypeSchema.enum.project:
         return this.getFolderReferences(pathTo.projects);
-      case objectTypeSchema.Enum.collection:
+      case objectTypeSchema.enum.collection:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFolderReferences(pathTo.collections(projectId));
-      case objectTypeSchema.Enum.entry:
+      case objectTypeSchema.enum.entry:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -1872,7 +1972,7 @@ var AbstractCrudService = class {
         return this.getFileReferences(
           pathTo.collection(projectId, collectionId)
         );
-      case objectTypeSchema.Enum.sharedValue:
+      case objectTypeSchema.enum.sharedValue:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -1889,7 +1989,10 @@ var AbstractCrudService = class {
       };
       try {
         return fileReferenceSchema.parse(folderReference);
-      } catch (error) {
+      } catch {
+        this.logService.warn(
+          `[getFolderReferences] Ignoring folder "${possibleFolder.name}" in "${path}" as it does not match the expected format`
+        );
         return null;
       }
     });
@@ -1912,7 +2015,10 @@ var AbstractCrudService = class {
         };
         try {
           return fileReferenceSchema.parse(fileReference);
-        } catch (error) {
+        } catch {
+          this.logService.warn(
+            `[getFileReferences] Ignoring file "${possibleFile.name}" in "${path}" as it does not match the expected format`
+          );
           return null;
         }
       })
@@ -1947,13 +2053,10 @@ function slug(string) {
 
 // src/service/AssetService.ts
 var AssetService = class extends AbstractCrudService {
-  // @ts-ignore
-  logService;
   jsonFileService;
   gitService;
   constructor(options, logService, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Asset, options);
-    this.logService = logService;
+    super(serviceTypeSchema.enum.Asset, options, logService);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -2111,7 +2214,7 @@ var AssetService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const assetReferences = await this.listReferences(
-      objectTypeSchema.Enum.asset,
+      objectTypeSchema.enum.asset,
       props.projectId
     );
     const partialAssetReferences = assetReferences.slice(offset, limit);
@@ -2132,7 +2235,7 @@ var AssetService = class extends AbstractCrudService {
   }
   async count(props) {
     countAssetsSchema.parse(props);
-    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
+    const count = (await this.listReferences(objectTypeSchema.enum.asset, props.projectId)).length;
     return count;
   }
   /**
@@ -2202,8 +2305,8 @@ import Fs3 from "fs-extra";
 var CollectionService = class extends AbstractCrudService {
   jsonFileService;
   gitService;
-  constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Collection, options);
+  constructor(options, logService, jsonFileService, gitService) {
+    super(serviceTypeSchema.enum.Collection, options, logService);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
@@ -2319,7 +2422,7 @@ var CollectionService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const collectionReferences = await this.listReferences(
-      objectTypeSchema.Enum.collection,
+      objectTypeSchema.enum.collection,
       props.projectId
     );
     const partialCollectionReferences = collectionReferences.slice(
@@ -2344,7 +2447,7 @@ var CollectionService = class extends AbstractCrudService {
   async count(props) {
     countCollectionsSchema.parse(props);
     const count = (await this.listReferences(
-      objectTypeSchema.Enum.collection,
+      objectTypeSchema.enum.collection,
       props.projectId
     )).length;
     return count;
@@ -2382,14 +2485,12 @@ var CollectionService = class extends AbstractCrudService {
 // src/service/EntryService.ts
 import Fs4 from "fs-extra";
 var EntryService = class extends AbstractCrudService {
-  logService;
   jsonFileService;
   gitService;
   collectionService;
   // private sharedValueService: SharedValueService;
   constructor(options, logService, jsonFileService, gitService, collectionService) {
-    super(serviceTypeSchema.Enum.Entry, options);
-    this.logService = logService;
+    super(serviceTypeSchema.enum.Entry, options, logService);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
@@ -2422,11 +2523,11 @@ var EntryService = class extends AbstractCrudService {
       props.collectionId,
       entryFile
     );
-    this.validateValues({
-      collectionId: props.collectionId,
-      fieldDefinitions: collection.fieldDefinitions,
-      values: entry.values
-    });
+    const createEntrySchemaFromFieldDefinitions = getCreateEntrySchemaFromFieldDefinitions(
+      collection.fieldDefinitions,
+      entry.values
+    );
+    createEntrySchemaFromFieldDefinitions.parse(props);
     await this.jsonFileService.create(
       entryFile,
       entryFilePath,
@@ -2499,11 +2600,11 @@ var EntryService = class extends AbstractCrudService {
       props.collectionId,
       entryFile
     );
-    this.validateValues({
-      collectionId: props.collectionId,
-      fieldDefinitions: collection.fieldDefinitions,
-      values: entry.values
-    });
+    const updateEntrySchemaFromFieldDefinitions = getUpdateEntrySchemaFromFieldDefinitions(
+      collection.fieldDefinitions,
+      entry.values
+    );
+    updateEntrySchemaFromFieldDefinitions.parse(props);
     await this.jsonFileService.update(
       entryFile,
       entryFilePath,
@@ -2547,7 +2648,7 @@ var EntryService = class extends AbstractCrudService {
     const offset = props.offset || 0;
     const limit = props.limit || 15;
     const entryReferences = await this.listReferences(
-      objectTypeSchema.Enum.entry,
+      objectTypeSchema.enum.entry,
       props.projectId,
       props.collectionId
     );
@@ -2571,7 +2672,7 @@ var EntryService = class extends AbstractCrudService {
   async count(props) {
     countEntriesSchema.parse(props);
     return (await this.listReferences(
-      objectTypeSchema.Enum.entry,
+      objectTypeSchema.enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -2588,47 +2689,6 @@ var EntryService = class extends AbstractCrudService {
   migrate(potentiallyOutdatedEntryFile) {
     return entryFileSchema.parse(potentiallyOutdatedEntryFile);
   }
-  /**
-   * Returns a Field definition by ID
-   */
-  getFieldDefinitionById(props) {
-    const fieldDefinition = props.fieldDefinitions.find((definition) => {
-      if (definition.id === props.id) {
-        return true;
-      }
-      return false;
-    });
-    if (!fieldDefinition) {
-      throw new Error(
-        `No Field definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
-      );
-    }
-    return fieldDefinition;
-  }
-  /**
-   * Validates given Values against their Collections Field definitions
-   */
-  validateValues(props) {
-    props.values.map((value) => {
-      const fieldDefinition = this.getFieldDefinitionById({
-        collectionId: props.collectionId,
-        fieldDefinitions: props.fieldDefinitions,
-        id: value.fieldDefinitionId
-      });
-      const contentSchema = getValueContentSchemaFromFieldDefinition(fieldDefinition);
-      this.logService.debug(
-        "Validating Value against content schema generated from Field definition",
-        {
-          value,
-          contentSchema,
-          fieldDefinition
-        }
-      );
-      for (const [_language, content] of Object.entries(value.content)) {
-        contentSchema.parse(content);
-      }
-    });
-  }
   /**
    * Creates an Entry from given EntryFile by resolving it's Values
    */
@@ -2651,8 +2711,8 @@ import Path2 from "path";
 // src/service/GitTagService.ts
 var GitTagService = class extends AbstractCrudService {
   git;
-  constructor(options, git) {
-    super(serviceTypeSchema.Enum.GitTag, options);
+  constructor(options, git, logService) {
+    super(serviceTypeSchema.enum.GitTag, options, logService);
     this.git = git;
   }
   /**
@@ -2796,7 +2856,11 @@ var GitService = class {
       concurrency: 1
       // No concurrency because git operations are sequencial
     });
-    this.gitTagService = new GitTagService(options, this.git.bind(this));
+    this.gitTagService = new GitTagService(
+      options,
+      this.git.bind(this),
+      logService
+    );
     this.logService = logService;
     this.userService = userService;
     this.updateVersion();
@@ -3322,10 +3386,8 @@ var GitService = class {
 import Fs5 from "fs-extra";
 var JsonFileService = class extends AbstractCrudService {
   cache = /* @__PURE__ */ new Map();
-  logService;
   constructor(options, logService) {
-    super(serviceTypeSchema.Enum.JsonFile, options);
-    this.logService = logService;
+    super(serviceTypeSchema.enum.JsonFile, options, logService);
   }
   /**
    * Creates a new file on disk. Fails if path already exists
@@ -3342,7 +3404,9 @@ var JsonFileService = class extends AbstractCrudService {
       flag: "wx",
       encoding: "utf8"
     });
-    this.options.file.cache === true && this.cache.set(path, parsedData);
+    if (this.options.file.cache === true) {
+      this.cache.set(path, parsedData);
+    }
     this.logService.debug(`Created file "${path}"`);
     return parsedData;
   }
@@ -3367,7 +3431,9 @@ var JsonFileService = class extends AbstractCrudService {
     });
     const json = this.deserialize(data);
     const parsedData = schema.parse(json);
-    this.options.file.cache === true && this.cache.set(path, parsedData);
+    if (this.options.file.cache === true) {
+      this.cache.set(path, parsedData);
+    }
     return parsedData;
   }
   /**
@@ -3408,7 +3474,9 @@ var JsonFileService = class extends AbstractCrudService {
       flag: "w",
       encoding: "utf8"
     });
-    this.options.file.cache === true && this.cache.set(path, parsedData);
+    if (this.options.file.cache === true) {
+      this.cache.set(path, parsedData);
+    }
     this.logService.debug(`Updated file "${path}"`);
     return parsedData;
   }
@@ -3509,7 +3577,6 @@ var SynchronizeLocalChangesError = class extends Error {
 // src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
   coreVersion;
-  logService;
   jsonFileService;
   userService;
   gitService;
@@ -3517,9 +3584,8 @@ var ProjectService = class extends AbstractCrudService {
   collectionService;
   entryService;
   constructor(coreVersion, options, logService, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
-    super(serviceTypeSchema.Enum.Project, options);
+    super(serviceTypeSchema.enum.Project, options, logService);
     this.coreVersion = coreVersion;
-    this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
@@ -3561,7 +3627,7 @@ var ProjectService = class extends AbstractCrudService {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
       await this.gitService.init(projectPath, {
-        initialBranch: projectBranchSchema.Enum.production
+        initialBranch: projectBranchSchema.enum.production
       });
       await this.jsonFileService.create(
         projectFile,
@@ -3575,7 +3641,7 @@ var ProjectService = class extends AbstractCrudService {
       });
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work,
+        projectBranchSchema.enum.work,
         {
           isNew: true
         }
@@ -3677,10 +3743,10 @@ var ProjectService = class extends AbstractCrudService {
     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) {
+    if (currentBranch !== projectBranchSchema.enum.work) {
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
     }
     const currentProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
@@ -3740,7 +3806,7 @@ var ProjectService = class extends AbstractCrudService {
       await this.update(migratedProjectFile);
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
       await this.gitService.merge(projectPath, upgradeBranchName, {
         squash: true
@@ -3768,7 +3834,7 @@ var ProjectService = class extends AbstractCrudService {
     } catch (error) {
       await this.gitService.branches.switch(
         projectPath,
-        projectBranchSchema.Enum.work
+        projectBranchSchema.enum.work
       );
       await this.gitService.branches.delete(
         projectPath,
@@ -3830,9 +3896,7 @@ var ProjectService = class extends AbstractCrudService {
   async getChanges(props) {
     getChangesProjectSchema.parse(props);
     const projectPath = pathTo.project(props.id);
-    const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(
-      projectPath
-    );
+    const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(projectPath);
     if (hasRemoteOrigin === false) {
       throw new Error(`Project "${props.id}" does not have a remote origin`);
     }
@@ -3887,7 +3951,7 @@ var ProjectService = class extends AbstractCrudService {
    */
   async listOutdated() {
     const projectReferences = await this.listReferences(
-      objectTypeSchema.Enum.project
+      objectTypeSchema.enum.project
     );
     const result = await Promise.all(
       projectReferences.map(async (reference) => {
@@ -3910,7 +3974,7 @@ var ProjectService = class extends AbstractCrudService {
     const offset = props?.offset || 0;
     const limit = props?.limit || 15;
     const projectReferences = await this.listReferences(
-      objectTypeSchema.Enum.project
+      objectTypeSchema.enum.project
     );
     const partialProjectReferences = projectReferences.slice(offset, limit);
     const projects = await returnResolved(
@@ -3926,7 +3990,7 @@ var ProjectService = class extends AbstractCrudService {
     };
   }
   async count() {
-    return (await this.listReferences(objectTypeSchema.Enum.project)).length;
+    return (await this.listReferences(objectTypeSchema.enum.project)).length;
   }
   /**
    * Checks if given object is of type Project
@@ -3999,7 +4063,7 @@ var ProjectService = class extends AbstractCrudService {
    * committed
    */
   async createFolderStructure(path) {
-    const folders2 = Object.values(projectFolderSchema.Values);
+    const folders2 = Object.values(projectFolderSchema.enum);
     await Promise.all(
       folders2.map(async (folder) => {
         await Fs6.mkdirp(Path4.join(path, folder));
@@ -4023,9 +4087,9 @@ var ProjectService = class extends AbstractCrudService {
       "!/**/.gitkeep",
       "",
       "# elek.io related ignores"
-      // projectFolderSchema.Enum.theme + '/',
-      // projectFolderSchema.Enum.public + '/',
-      // projectFolderSchema.Enum.logs + '/',
+      // projectFolderSchema.enum.theme + '/',
+      // projectFolderSchema.enum.public + '/',
+      // projectFolderSchema.enum.logs + '/',
     ];
     await Fs6.writeFile(Path4.join(path, ".gitignore"), lines.join(Os2.EOL));
   }
@@ -4033,9 +4097,7 @@ var ProjectService = class extends AbstractCrudService {
     switch (objectType) {
       case "asset": {
         const assetFilePath = pathTo.assetFile(projectId, reference.id);
-        const prevAssetFile = await this.jsonFileService.unsafeRead(
-          assetFilePath
-        );
+        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}"`, {
@@ -4049,9 +4111,7 @@ var ProjectService = class extends AbstractCrudService {
           projectId,
           reference.id
         );
-        const prevCollectionFile = await this.jsonFileService.unsafeRead(
-          collectionFilePath
-        );
+        const prevCollectionFile = await this.jsonFileService.unsafeRead(collectionFilePath);
         const migratedCollectionFile = this.collectionService.migrate(prevCollectionFile);
         await this.collectionService.update({
           projectId,
@@ -4072,9 +4132,7 @@ var ProjectService = class extends AbstractCrudService {
           collectionId,
           reference.id
         );
-        const prevEntryFile = await this.jsonFileService.unsafeRead(
-          entryFilePath
-        );
+        const prevEntryFile = await this.jsonFileService.unsafeRead(entryFilePath);
         const migratedEntryFile = this.entryService.migrate(prevEntryFile);
         await this.entryService.update({
           projectId,
@@ -4109,7 +4167,7 @@ var UserService = class {
   async get() {
     try {
       return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
-    } catch (error) {
+    } catch {
       this.logService.info("No User found");
       return null;
     }
@@ -4125,7 +4183,7 @@ var UserService = class {
     const userFile = {
       ...props
     };
-    if (userFile.userType === UserTypeSchema.Enum.cloud) {
+    if (userFile.userType === UserTypeSchema.enum.cloud) {
     }
     await this.jsonFileService.update(userFile, userFilePath, userFileSchema);
     this.logService.debug("Updated User");
@@ -4174,6 +4232,7 @@ var ElekIoCore = class {
     );
     this.collectionService = new CollectionService(
       this.options,
+      this.logService,
       this.jsonFileService,
       this.gitService
     );
@@ -4320,8 +4379,10 @@ export {
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
+  getCreateEntrySchemaFromFieldDefinitions,
   getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromFieldDefinition,
+  getUpdateEntrySchemaFromFieldDefinitions,
+  getValueSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
   gitCommitSchema,
   gitInitOptionsSchema,
@@ -4331,7 +4392,7 @@ export {
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
-  ipFieldDefinitionSchema,
+  ipv4FieldDefinitionSchema,
   listAssetsSchema,
   listBranchesProjectSchema,
   listCollectionsSchema,