@elek-io/core 0.14.4 → 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.4",
+  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.18.1",
+    "@hono/node-server": "1.19.5",
     "@hono/swagger-ui": "0.5.2",
-    "@hono/zod-openapi": "1.1.0",
-    "@sindresorhus/slugify": "2.2.1",
-    "fs-extra": "11.3.1",
-    hono: "4.9.0",
-    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: "4.0.17"
+    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.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";
@@ -543,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(),
@@ -665,104 +674,6 @@ 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 = null;
-  switch (definition.fieldType) {
-    case FieldTypeSchema.enum.email:
-      schema = z7.email();
-      break;
-    case FieldTypeSchema.enum.url:
-      schema = z7.url();
-      break;
-    case FieldTypeSchema.enum.ipv4:
-      schema = z7.ipv4();
-      break;
-    case FieldTypeSchema.enum.date:
-      schema = z7.iso.date();
-      break;
-    case FieldTypeSchema.enum.time:
-      schema = z7.iso.time();
-      break;
-    case FieldTypeSchema.enum.datetime:
-      schema = z7.iso.datetime();
-      break;
-    case FieldTypeSchema.enum.telephone:
-      schema = z7.e164();
-      break;
-    case FieldTypeSchema.enum.text:
-    case FieldTypeSchema.enum.textarea:
-      schema = z7.string().trim();
-      break;
-  }
-  if ("min" in definition && definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if ("max" in definition && definition.max) {
-    schema = schema.max(definition.max);
-  }
-  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({
@@ -968,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",
@@ -983,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({
@@ -1003,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;
 
@@ -1077,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",
@@ -1085,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"
       })
@@ -1114,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",
@@ -1127,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"
@@ -1141,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",
@@ -1172,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;
@@ -1214,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",
@@ -1222,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"
       })
@@ -1251,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",
@@ -1264,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"
@@ -1278,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",
@@ -1309,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;
@@ -1353,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",
@@ -1367,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"
       })
@@ -1396,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",
@@ -1415,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"
@@ -1429,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",
@@ -1466,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;
@@ -1499,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"
       })
@@ -1531,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"
@@ -1545,7 +1629,7 @@ var readProjectRoute = createRoute4({
   path: "/projects/{projectId}",
   operationId: "readProject",
   request: {
-    params: z16.object({
+    params: z17.object({
       projectId: uuidSchema.openapi({
         param: {
           name: "projectId",
@@ -1847,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
@@ -1903,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;
       }
     });
@@ -1926,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;
         }
       })
@@ -1961,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;
   }
@@ -2216,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;
   }
@@ -2396,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;
@@ -2436,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,
@@ -2513,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,
@@ -2602,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
    */
@@ -2665,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;
   }
   /**
@@ -2810,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();
@@ -3336,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
@@ -3356,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;
   }
@@ -3381,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;
   }
   /**
@@ -3422,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;
   }
@@ -3523,7 +3577,6 @@ var SynchronizeLocalChangesError = class extends Error {
 // src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
   coreVersion;
-  logService;
   jsonFileService;
   userService;
   gitService;
@@ -3531,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;
@@ -3844,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`);
     }
@@ -4047,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}"`, {
@@ -4063,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,
@@ -4086,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,
@@ -4123,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;
     }
@@ -4188,6 +4232,7 @@ var ElekIoCore = class {
     );
     this.collectionService = new CollectionService(
       this.options,
+      this.logService,
       this.jsonFileService,
       this.gitService
     );
@@ -4334,8 +4379,10 @@ export {
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
+  getCreateEntrySchemaFromFieldDefinitions,
   getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromFieldDefinition,
+  getUpdateEntrySchemaFromFieldDefinitions,
+  getValueSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
   gitCommitSchema,
   gitInitOptionsSchema,