@elek-io/core 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -113,11 +113,11 @@ var pathTo = {
       `${id}.${language}.json`
     );
   },
-  values: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), "values");
+  sharedValues: (projectId) => {
+    return import_path.default.join(pathTo.project(projectId), "shared-values");
   },
-  valueFile: (projectId, id, language) => {
-    return import_path.default.join(pathTo.values(projectId), `${id}.${language}.json`);
+  sharedValueFile: (projectId, id, language) => {
+    return import_path.default.join(pathTo.sharedValues(projectId), `${id}.${language}.json`);
   },
   assets: (projectId) => {
     return import_path.default.join(
@@ -314,19 +314,19 @@ var AbstractCrudService = class {
    */
   async listReferences(type, projectId, collectionId) {
     switch (type) {
-      case import_shared2.fileTypeSchema.Enum.asset:
+      case import_shared2.objectTypeSchema.Enum.asset:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
-      case import_shared2.fileTypeSchema.Enum.project:
+      case import_shared2.objectTypeSchema.Enum.project:
         return this.getFolderReferences(pathTo.projects);
-      case import_shared2.fileTypeSchema.Enum.collection:
+      case import_shared2.objectTypeSchema.Enum.collection:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFolderReferences(pathTo.collections(projectId));
-      case import_shared2.fileTypeSchema.Enum.entry:
+      case import_shared2.objectTypeSchema.Enum.entry:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -336,11 +336,11 @@ var AbstractCrudService = class {
         return this.getFileReferences(
           pathTo.collection(projectId, collectionId)
         );
-      case import_shared2.fileTypeSchema.Enum.value:
+      case import_shared2.objectTypeSchema.Enum.sharedValue:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
-        return this.getFileReferences(pathTo.values(projectId));
+        return this.getFileReferences(pathTo.sharedValues(projectId));
       default:
         throw new Error(`Trying to list files of unsupported type "${type}"`);
     }
@@ -1020,7 +1020,7 @@ var AssetService = class extends AbstractCrudService {
     );
     const assetFile = {
       ...props,
-      fileType: "asset",
+      objectType: "asset",
       id,
       created: (0, import_shared7.currentTimestamp)(),
       extension: fileType.extension,
@@ -1129,7 +1129,7 @@ var AssetService = class extends AbstractCrudService {
   async list(props) {
     import_shared7.listAssetsSchema.parse(props);
     const assetReferences = await this.listReferences(
-      import_shared7.fileTypeSchema.Enum.asset,
+      import_shared7.objectTypeSchema.Enum.asset,
       props.projectId
     );
     const list = await returnResolved(
@@ -1155,7 +1155,7 @@ var AssetService = class extends AbstractCrudService {
   }
   async count(props) {
     import_shared7.countAssetsSchema.parse(props);
-    const count = (await this.listReferences(import_shared7.fileTypeSchema.Enum.asset, props.projectId)).length;
+    const count = (await this.listReferences(import_shared7.objectTypeSchema.Enum.asset, props.projectId)).length;
     return count;
   }
   /**
@@ -1203,14 +1203,14 @@ var AssetService = class extends AbstractCrudService {
       const fileBuffer = await import_fs_extra3.default.readFile(filePath);
       if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
         return {
-          extension: import_shared7.supportedExtensionSchema.Enum.svg,
-          mimeType: import_shared7.supportedMimeTypeSchema.Enum["image/svg+xml"]
+          extension: import_shared7.supportedAssetExtensionSchema.Enum.svg,
+          mimeType: import_shared7.supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
         };
       }
     }
     const { fileTypeFromFile } = await import("file-type");
     const fileType = await fileTypeFromFile(filePath);
-    const result = import_shared7.supportedFileTypeSchema.parse({
+    const result = import_shared7.supportedAssetTypeSchema.parse({
       extension: fileType?.ext,
       mimeType: fileType?.mime
     });
@@ -1241,7 +1241,7 @@ var CollectionService = class extends AbstractCrudService {
     );
     const collectionFile = {
       ...props,
-      fileType: "collection",
+      objectType: "collection",
       id,
       slug: {
         singular: (0, import_shared8.slug)(props.slug.singular),
@@ -1321,7 +1321,7 @@ var CollectionService = class extends AbstractCrudService {
   async list(props) {
     import_shared8.listCollectionsSchema.parse(props);
     const references = await this.listReferences(
-      import_shared8.fileTypeSchema.Enum.collection,
+      import_shared8.objectTypeSchema.Enum.collection,
       props.projectId
     );
     const list = await returnResolved(
@@ -1342,7 +1342,10 @@ var CollectionService = class extends AbstractCrudService {
   }
   async count(props) {
     import_shared8.countCollectionsSchema.parse(props);
-    const count = (await this.listReferences(import_shared8.fileTypeSchema.Enum.collection, props.projectId)).length;
+    const count = (await this.listReferences(
+      import_shared8.objectTypeSchema.Enum.collection,
+      props.projectId
+    )).length;
     return count;
   }
   /**
@@ -1357,86 +1360,94 @@ var CollectionService = class extends AbstractCrudService {
 var import_shared10 = require("@elek-io/shared");
 var import_fs_extra6 = __toESM(require("fs-extra"), 1);
 
-// src/service/ValueService.ts
+// src/service/SharedValueService.ts
 var import_shared9 = require("@elek-io/shared");
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
-var ValueService = class extends AbstractCrudService {
+var SharedValueService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService, assetService) {
     super(import_shared9.serviceTypeSchema.Enum.Value, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
   /**
-   * Creates a new Value
+   * Creates a new shared Value
    */
   async create(props) {
-    import_shared9.createValueSchema.parse(props);
+    import_shared9.createSharedValueSchema.parse(props);
     const id = (0, import_shared9.uuid)();
     const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.valueFile(
+    const sharedValueFilePath = pathTo.sharedValueFile(
       props.projectId,
       id,
       props.language
     );
-    const valueFile = {
+    const sharedValueFile = {
       ...props,
-      fileType: "value",
+      objectType: "sharedValue",
       id,
       created: (0, import_shared9.currentTimestamp)()
     };
+    this.validate(sharedValueFile);
     await this.jsonFileService.create(
-      valueFile,
-      valueFilePath,
-      import_shared9.valueFileSchema
+      sharedValueFile,
+      sharedValueFilePath,
+      import_shared9.sharedValueFileSchema
     );
-    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.add(projectPath, [sharedValueFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
-    return valueFile;
+    return sharedValueFile;
   }
   /**
-   * Returns a Value by ID and language
+   * Returns a shared Value by ID and language
    */
   async read(props) {
-    import_shared9.readValueSchema.parse(props);
-    const valueFile = await this.jsonFileService.read(
-      pathTo.valueFile(props.projectId, props.id, props.language),
-      import_shared9.valueFileSchema
+    import_shared9.readSharedValueSchema.parse(props);
+    const sharedValueFile = await this.jsonFileService.read(
+      pathTo.sharedValueFile(
+        props.projectId,
+        props.id,
+        props.language
+      ),
+      import_shared9.sharedValueFileSchema
     );
-    return valueFile;
+    return sharedValueFile;
   }
   /**
-   * Updates given Value
+   * Updates given shared Values content
+   *
+   * The valueType cannot be changed after creating the shared Value
    */
   async update(props) {
-    import_shared9.updateValueSchema.parse(props);
+    import_shared9.updateSharedValueSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.valueFile(
+    const sharedValueFilePath = pathTo.sharedValueFile(
       props.projectId,
       props.id,
       props.language
     );
-    const prevValueFile = await this.read(props);
-    const valueFile = {
-      ...prevValueFile,
-      ...props,
+    const prevSharedValueFile = await this.read(props);
+    const sharedValueFile = {
+      ...prevSharedValueFile,
+      content: props.content,
       updated: (0, import_shared9.currentTimestamp)()
     };
+    this.validate(sharedValueFile);
     await this.jsonFileService.update(
-      valueFile,
-      valueFilePath,
-      import_shared9.valueFileSchema
+      sharedValueFile,
+      sharedValueFilePath,
+      import_shared9.sharedValueFileSchema
     );
-    await this.gitService.add(projectPath, [valueFilePath]);
+    await this.gitService.add(projectPath, [sharedValueFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
-    return valueFile;
+    return sharedValueFile;
   }
   /**
-   * Deletes given Value
+   * Deletes given shared Value
    */
   async delete(props) {
-    import_shared9.deleteValueSchema.parse(props);
+    import_shared9.deleteSharedValueSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.valueFile(
+    const valueFilePath = pathTo.sharedValueFile(
       props.projectId,
       props.id,
       props.language
@@ -1446,9 +1457,9 @@ var ValueService = class extends AbstractCrudService {
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
-    import_shared9.listValuesSchema.parse(props);
+    import_shared9.listSharedValuesSchema.parse(props);
     const references = await this.listReferences(
-      import_shared9.fileTypeSchema.Enum.value,
+      import_shared9.objectTypeSchema.Enum.sharedValue,
       props.projectId
     );
     const list = await returnResolved(
@@ -1473,37 +1484,52 @@ var ValueService = class extends AbstractCrudService {
   }
   async count(props) {
     import_shared9.countValuesSchema.parse(props);
-    const count = (await this.listReferences(import_shared9.fileTypeSchema.Enum.value, props.projectId)).length;
+    const count = (await this.listReferences(
+      import_shared9.objectTypeSchema.Enum.sharedValue,
+      props.projectId
+    )).length;
     return count;
   }
   /**
-   * Checks if given object is of type Value
+   * Checks if given object is a shared Value
    */
-  isValue(obj) {
-    return import_shared9.valueFileSchema.safeParse(obj).success;
+  isSharedValue(obj) {
+    return import_shared9.sharedValueSchema.safeParse(obj).success;
   }
   /**
-   * Reads the given Value from disk and validates it against the ValueDefinition
+   * Reads the given shared Values content based on it's ValueType
    */
-  async validate(props) {
-    import_shared9.validateValueSchema.parse(props);
-    const value = await this.read(props);
-    const valueSchema = (0, import_shared9.getValueSchemaFromDefinition)(props.definition);
-    return valueSchema.safeParse(value.content);
+  validate(sharedValue) {
+    switch (sharedValue.valueType) {
+      case import_shared9.ValueTypeSchema.Enum.boolean:
+        import_shared9.z.boolean().parse(sharedValue.content);
+        break;
+      case import_shared9.ValueTypeSchema.Enum.number:
+        import_shared9.z.number().parse(sharedValue.content);
+        break;
+      case import_shared9.ValueTypeSchema.Enum.string:
+        import_shared9.z.string().parse(sharedValue.content);
+        break;
+      default:
+        throw new Error(
+          `Error validating content of unsupported shared Value with ValueType "${sharedValue.valueType}"`
+        );
+    }
   }
 };
 
 // src/service/EntryService.ts
 var EntryService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService, collectionService, valueService) {
+  constructor(options, jsonFileService, gitService, collectionService, assetService, sharedValueService) {
     super(import_shared10.serviceTypeSchema.Enum.Entry, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
-    this.valueService = valueService;
+    this.assetService = assetService;
+    this.sharedValueService = sharedValueService;
   }
   /**
-   * Creates a new Entry
+   * Creates a new Entry for given Collection
    */
   async create(props) {
     import_shared10.createEntrySchema.parse(props);
@@ -1519,19 +1545,22 @@ var EntryService = class extends AbstractCrudService {
       projectId: props.projectId,
       id: props.collectionId
     });
-    await this.validateValueReferences(
-      props.projectId,
-      props.collectionId,
-      props.valueReferences,
-      collection.valueDefinitions
-    );
     const entryFile = {
-      fileType: "entry",
+      objectType: "entry",
       id,
       language: props.language,
-      valueReferences: props.valueReferences,
+      values: props.values,
       created: (0, import_shared10.currentTimestamp)()
     };
+    const entry = await this.toEntry({
+      projectId: props.projectId,
+      entryFile
+    });
+    this.validateValues({
+      collectionId: props.collectionId,
+      valueDefinitions: collection.valueDefinitions,
+      values: entry.values
+    });
     await this.jsonFileService.create(
       entryFile,
       entryFilePath,
@@ -1539,10 +1568,10 @@ var EntryService = class extends AbstractCrudService {
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
-    return entryFile;
+    return entry;
   }
   /**
-   * Returns an Entry by ID and language
+   * Returns an Entry from given Collection by ID and language
    */
   async read(props) {
     import_shared10.readEntrySchema.parse(props);
@@ -1555,10 +1584,10 @@ var EntryService = class extends AbstractCrudService {
       ),
       import_shared10.entryFileSchema
     );
-    return entryFile;
+    return await this.toEntry({ projectId: props.projectId, entryFile });
   }
   /**
-   * Updates Entry with given ValueReferences
+   * Updates an Entry of given Collection with new Values and shared Values
    */
   async update(props) {
     import_shared10.updateEntrySchema.parse(props);
@@ -1573,12 +1602,6 @@ var EntryService = class extends AbstractCrudService {
       projectId: props.projectId,
       id: props.collectionId
     });
-    await this.validateValueReferences(
-      props.projectId,
-      props.collectionId,
-      props.valueReferences,
-      collection.valueDefinitions
-    );
     const prevEntryFile = await this.read({
       projectId: props.projectId,
       collectionId: props.collectionId,
@@ -1587,9 +1610,18 @@ var EntryService = class extends AbstractCrudService {
     });
     const entryFile = {
       ...prevEntryFile,
-      valueReferences: props.valueReferences,
+      values: props.values,
       updated: (0, import_shared10.currentTimestamp)()
     };
+    const entry = await this.toEntry({
+      projectId: props.projectId,
+      entryFile
+    });
+    this.validateValues({
+      collectionId: props.collectionId,
+      valueDefinitions: collection.valueDefinitions,
+      values: entry.values
+    });
     await this.jsonFileService.update(
       entryFile,
       entryFilePath,
@@ -1597,10 +1629,10 @@ var EntryService = class extends AbstractCrudService {
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
-    return entryFile;
+    return entry;
   }
   /**
-   * Deletes given Entry
+   * Deletes given Entry from it's Collection
    */
   async delete(props) {
     import_shared10.deleteEntrySchema.parse(props);
@@ -1618,7 +1650,7 @@ var EntryService = class extends AbstractCrudService {
   async list(props) {
     import_shared10.listEntriesSchema.parse(props);
     const references = await this.listReferences(
-      import_shared10.fileTypeSchema.Enum.entry,
+      import_shared10.objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     );
@@ -1646,45 +1678,147 @@ var EntryService = class extends AbstractCrudService {
   async count(props) {
     import_shared10.countEntriesSchema.parse(props);
     return (await this.listReferences(
-      import_shared10.fileTypeSchema.Enum.entry,
+      import_shared10.objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     )).length;
   }
   /**
-   * Checks if given object of Collection, CollectionItem,
-   * Field, Project or Asset is of type CollectionItem
+   * Checks if given object is of type Entry
    */
   isEntry(obj) {
     return import_shared10.entrySchema.safeParse(obj).success;
   }
   /**
-   * Validates referenced Values against the Collections definition
-   *
-   * @todo should probably return all errors occurring during parsing instead of throwing
+   * Returns a Value definition by ID
    */
-  async validateValueReferences(projectId, collectionId, valueReferences, valueDefinitions) {
-    await Promise.all(
-      valueReferences.map(async (reference) => {
-        const definition = valueDefinitions.find((def) => {
-          if (def.id === reference.definitionId) {
-            return true;
-          }
-          return false;
+  getValueDefinitionById(props) {
+    const definition = props.valueDefinitions.find((def) => {
+      if (def.id === props.id) {
+        return true;
+      }
+      return false;
+    });
+    if (!definition) {
+      throw new Error(
+        `No definition with ID "${props.id}" found in Collection "${props.collectionId}" for given Value reference`
+      );
+    }
+    return definition;
+  }
+  /**
+   * Validates given Values against it's Collections definitions
+   */
+  validateValues(props) {
+    props.values.map((value) => {
+      const definition = this.getValueDefinitionById({
+        collectionId: props.collectionId,
+        valueDefinitions: props.valueDefinitions,
+        id: value.definitionId
+      });
+      const schema = (0, import_shared10.getValueContentSchemaFromDefinition)(definition);
+      try {
+        schema.parse(value.content);
+      } catch (error) {
+        console.log("Definition:", definition);
+        console.log("Value:", value);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Validates given shared Value references against it's Collections definitions
+   */
+  // private validateResolvedSharedValues(props: {
+  //   collectionId: string;
+  //   valueDefinitions: ValueDefinition[];
+  //   resolvedSharedValues: ResolvedSharedValueReference[];
+  // }) {
+  //   props.resolvedSharedValues.map((value) => {
+  //     const definition = this.getValueDefinitionById({
+  //       collectionId: props.collectionId,
+  //       valueDefinitions: props.valueDefinitions,
+  //       id: value.definitionId,
+  //     });
+  //     const schema = getValueSchemaFromDefinition(definition);
+  //     schema.parse(value.resolved.content);
+  //   });
+  // }
+  async resolveValueContentReference(props) {
+    switch (props.valueContentReference.referenceObjectType) {
+      case import_shared10.objectTypeSchema.Enum.asset:
+        return this.resolveValueContentReferenceToAsset({
+          projectId: props.projectId,
+          valueContentReferenceToAsset: props.valueContentReference
         });
-        if (!definition) {
-          throw new Error(
-            `No definition with ID "${reference.definitionId}" found in Collection "${collectionId}" for given Value reference`
-          );
-        }
-        const schema = (0, import_shared10.getValueSchemaFromDefinition)(definition);
-        const value = await this.valueService.read({
-          ...reference.references,
-          projectId
+      case import_shared10.objectTypeSchema.Enum.sharedValue:
+        return this.resolveValueContentReferenceToSharedValue({
+          projectId: props.projectId,
+          valueContentReferenceToSharedValue: props.valueContentReference
         });
-        schema.parse(value.content);
+      default:
+        throw new Error(
+          // @ts-ignore
+          `Tried to resolve unsupported Value reference "${props.valueContentReference.referenceObjectType}"`
+        );
+    }
+  }
+  async resolveValueContentReferenceToAsset(props) {
+    const resolvedReferences = await Promise.all(
+      props.valueContentReferenceToAsset.references.map(async (reference) => {
+        const resolvedAsset = await this.assetService.read({
+          projectId: props.projectId,
+          id: reference.id,
+          language: reference.language
+        });
+        return {
+          ...reference,
+          resolved: resolvedAsset
+        };
       })
     );
+    return {
+      ...props.valueContentReferenceToAsset,
+      references: resolvedReferences
+    };
+  }
+  async resolveValueContentReferenceToSharedValue(props) {
+    const resolvedSharedValue = await this.sharedValueService.read({
+      projectId: props.projectId,
+      id: props.valueContentReferenceToSharedValue.references.id,
+      language: props.valueContentReferenceToSharedValue.references.language
+    });
+    return {
+      ...props.valueContentReferenceToSharedValue,
+      references: {
+        ...props.valueContentReferenceToSharedValue.references,
+        resolved: resolvedSharedValue
+      }
+    };
+  }
+  /**
+   * Creates an Entry from given EntryFile by resolving it's Values
+   */
+  async toEntry(props) {
+    const entry = {
+      ...props.entryFile,
+      values: await Promise.all(
+        props.entryFile.values.map(async (value) => {
+          if (value.valueType === import_shared10.ValueTypeSchema.Enum.reference) {
+            const resolvedValueContentReference = await this.resolveValueContentReference({
+              projectId: props.projectId,
+              valueContentReference: value.content
+            });
+            return {
+              ...value,
+              content: resolvedValueContentReference
+            };
+          }
+          return value;
+        })
+      )
+    };
+    return entry;
   }
 };
 
@@ -1719,7 +1853,7 @@ var SearchService = class extends AbstractCrudService {
    * @param project Project to search in
    * @param query Query to search for
    */
-  async search(projectId, query, fileType) {
+  async search(projectId, query, objectType) {
     const results = [];
     const normalizedQuery = query.trim();
     if (normalizedQuery === "") {
@@ -1732,7 +1866,7 @@ var SearchService = class extends AbstractCrudService {
           id: file.id,
           language: file.language,
           name: file.name,
-          type: file.fileType,
+          type: file.objectType,
           matches: []
         };
         for (const [key, value] of Object.entries(file)) {
@@ -1772,7 +1906,7 @@ var SearchService = class extends AbstractCrudService {
 
 // src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, userService, gitService, searchService, assetService, collectionService, entryService, valueService) {
+  constructor(options, jsonFileService, userService, gitService, searchService, assetService, collectionService, entryService) {
     super(import_shared12.serviceTypeSchema.Enum.Project, options);
     this.jsonFileService = jsonFileService;
     this.userService = userService;
@@ -1781,7 +1915,6 @@ var ProjectService = class extends AbstractCrudService {
     this.assetService = assetService;
     this.collectionService = collectionService;
     this.entryService = entryService;
-    this.valueService = valueService;
   }
   /**
    * Creates a new Project
@@ -1801,7 +1934,7 @@ var ProjectService = class extends AbstractCrudService {
     };
     const projectFile = {
       ...props,
-      fileType: "project",
+      objectType: "project",
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
@@ -1946,7 +2079,7 @@ var ProjectService = class extends AbstractCrudService {
     if (props) {
       import_shared12.listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(import_shared12.fileTypeSchema.Enum.project);
+    const references = await this.listReferences(import_shared12.objectTypeSchema.Enum.project);
     const list = await returnResolved(
       references.map((reference) => {
         return this.read({ id: reference.id });
@@ -1961,7 +2094,7 @@ var ProjectService = class extends AbstractCrudService {
     );
   }
   async count() {
-    return (await this.listReferences(import_shared12.fileTypeSchema.Enum.project)).length;
+    return (await this.listReferences(import_shared12.objectTypeSchema.Enum.project)).length;
   }
   /**
    * Search all models inside the project for given query
@@ -1982,6 +2115,7 @@ var ProjectService = class extends AbstractCrudService {
   /**
    * Exports given Project to JSON
    *
+   * @todo do not read everything before writing to disk -> stream into file given via props
    * @todo performance tests
    * @todo add progress callback
    */
@@ -1996,26 +2130,9 @@ var ProjectService = class extends AbstractCrudService {
           collectionId: collection.id,
           limit: 0
         })).list;
-        const entryExport = await Promise.all(
-          entries.map(async (entry) => {
-            const valueExport = await Promise.all(
-              entry.valueReferences.map(async (valueReference) => {
-                return this.valueService.read({
-                  projectId,
-                  id: valueReference.references.id,
-                  language: valueReference.references.language
-                });
-              })
-            );
-            return {
-              ...entry,
-              values: valueExport
-            };
-          })
-        );
         return {
           ...collection,
-          entries: entryExport
+          entries
         };
       })
     );
@@ -2085,23 +2202,24 @@ var ElekIoCore = class {
       this.jsonFileService,
       this.gitService
     );
-    this.valueService = new ValueService(
+    this.collectionService = new CollectionService(
       this.options,
       this.jsonFileService,
-      this.gitService,
-      this.assetService
+      this.gitService
     );
-    this.collectionService = new CollectionService(
+    this.sharedValueService = new SharedValueService(
       this.options,
       this.jsonFileService,
-      this.gitService
+      this.gitService,
+      this.assetService
     );
     this.entryService = new EntryService(
       this.options,
       this.jsonFileService,
       this.gitService,
       this.collectionService,
-      this.valueService
+      this.assetService,
+      this.sharedValueService
     );
     this.searchService = new SearchService(
       this.options,
@@ -2116,8 +2234,7 @@ var ElekIoCore = class {
       this.searchService,
       this.assetService,
       this.collectionService,
-      this.entryService,
-      this.valueService
+      this.entryService
     );
     if (this.options.environment !== "production") {
       console.info(
@@ -2170,8 +2287,8 @@ var ElekIoCore = class {
   /**
    * CRUD methods to work with Values
    */
-  get values() {
-    return this.valueService;
+  get sharedValues() {
+    return this.sharedValueService;
   }
 };
 //# sourceMappingURL=index.cjs.map