@elek-io/core 0.1.1 → 0.2.1

package/dist/index.js

@@ -18,13 +18,13 @@ import {
   createAssetSchema,
   currentTimestamp,
   deleteAssetSchema,
-  fileTypeSchema as fileTypeSchema2,
   listAssetsSchema,
+  objectTypeSchema as objectTypeSchema2,
   readAssetSchema,
   serviceTypeSchema as serviceTypeSchema3,
-  supportedExtensionSchema,
-  supportedFileTypeSchema,
-  supportedMimeTypeSchema,
+  supportedAssetExtensionSchema,
+  supportedAssetMimeTypeSchema,
+  supportedAssetTypeSchema,
   updateAssetSchema,
   uuid as uuid2
 } from "@elek-io/shared";
@@ -103,11 +103,11 @@ var pathTo = {
       `${id}.${language}.json`
     );
   },
-  values: (projectId) => {
-    return Path.join(pathTo.project(projectId), "values");
+  sharedValues: (projectId) => {
+    return Path.join(pathTo.project(projectId), "shared-values");
   },
-  valueFile: (projectId, id, language) => {
-    return Path.join(pathTo.values(projectId), `${id}.${language}.json`);
+  sharedValueFile: (projectId, id, language) => {
+    return Path.join(pathTo.sharedValues(projectId), `${id}.${language}.json`);
   },
   assets: (projectId) => {
     return Path.join(
@@ -235,8 +235,8 @@ function getDuplicates(arr, key) {
 // src/service/AbstractCrudService.ts
 import {
   fileReferenceSchema,
-  fileTypeSchema,
-  gitCommitIconSchema
+  gitCommitIconSchema,
+  objectTypeSchema
 } from "@elek-io/shared";
 import { orderBy, remove } from "lodash-es";
 var AbstractCrudService = class {
@@ -308,19 +308,19 @@ var AbstractCrudService = class {
    */
   async listReferences(type, projectId, collectionId) {
     switch (type) {
-      case fileTypeSchema.Enum.asset:
+      case objectTypeSchema.Enum.asset:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
-      case fileTypeSchema.Enum.project:
+      case objectTypeSchema.Enum.project:
         return this.getFolderReferences(pathTo.projects);
-      case fileTypeSchema.Enum.collection:
+      case objectTypeSchema.Enum.collection:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFolderReferences(pathTo.collections(projectId));
-      case fileTypeSchema.Enum.entry:
+      case objectTypeSchema.Enum.entry:
         if (!projectId) {
           throw new RequiredParameterMissingError("projectId");
         }
@@ -330,11 +330,11 @@ var AbstractCrudService = class {
         return this.getFileReferences(
           pathTo.collection(projectId, collectionId)
         );
-      case fileTypeSchema.Enum.value:
+      case 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}"`);
     }
@@ -1032,7 +1032,7 @@ var AssetService = class extends AbstractCrudService {
     );
     const assetFile = {
       ...props,
-      fileType: "asset",
+      objectType: "asset",
       id,
       created: currentTimestamp(),
       extension: fileType.extension,
@@ -1141,7 +1141,7 @@ var AssetService = class extends AbstractCrudService {
   async list(props) {
     listAssetsSchema.parse(props);
     const assetReferences = await this.listReferences(
-      fileTypeSchema2.Enum.asset,
+      objectTypeSchema2.Enum.asset,
       props.projectId
     );
     const list = await returnResolved(
@@ -1167,7 +1167,7 @@ var AssetService = class extends AbstractCrudService {
   }
   async count(props) {
     countAssetsSchema.parse(props);
-    const count = (await this.listReferences(fileTypeSchema2.Enum.asset, props.projectId)).length;
+    const count = (await this.listReferences(objectTypeSchema2.Enum.asset, props.projectId)).length;
     return count;
   }
   /**
@@ -1215,14 +1215,14 @@ var AssetService = class extends AbstractCrudService {
       const fileBuffer = await Fs3.readFile(filePath);
       if (IsSvg(fileBuffer.toString()) === true) {
         return {
-          extension: supportedExtensionSchema.Enum.svg,
-          mimeType: supportedMimeTypeSchema.Enum["image/svg+xml"]
+          extension: supportedAssetExtensionSchema.Enum.svg,
+          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
         };
       }
     }
     const { fileTypeFromFile } = await import("file-type");
     const fileType = await fileTypeFromFile(filePath);
-    const result = supportedFileTypeSchema.parse({
+    const result = supportedAssetTypeSchema.parse({
       extension: fileType?.ext,
       mimeType: fileType?.mime
     });
@@ -1237,8 +1237,8 @@ import {
   createCollectionSchema,
   currentTimestamp as currentTimestamp2,
   deleteCollectionSchema,
-  fileTypeSchema as fileTypeSchema3,
   listCollectionsSchema,
+  objectTypeSchema as objectTypeSchema3,
   readCollectionSchema,
   serviceTypeSchema as serviceTypeSchema4,
   slug,
@@ -1266,7 +1266,7 @@ var CollectionService = class extends AbstractCrudService {
     );
     const collectionFile = {
       ...props,
-      fileType: "collection",
+      objectType: "collection",
       id,
       slug: {
         singular: slug(props.slug.singular),
@@ -1346,7 +1346,7 @@ var CollectionService = class extends AbstractCrudService {
   async list(props) {
     listCollectionsSchema.parse(props);
     const references = await this.listReferences(
-      fileTypeSchema3.Enum.collection,
+      objectTypeSchema3.Enum.collection,
       props.projectId
     );
     const list = await returnResolved(
@@ -1367,7 +1367,10 @@ var CollectionService = class extends AbstractCrudService {
   }
   async count(props) {
     countCollectionsSchema.parse(props);
-    const count = (await this.listReferences(fileTypeSchema3.Enum.collection, props.projectId)).length;
+    const count = (await this.listReferences(
+      objectTypeSchema3.Enum.collection,
+      props.projectId
+    )).length;
     return count;
   }
   /**
@@ -1380,15 +1383,16 @@ var CollectionService = class extends AbstractCrudService {
 
 // src/service/EntryService.ts
 import {
+  ValueTypeSchema as ValueTypeSchema2,
   countEntriesSchema,
   createEntrySchema,
   currentTimestamp as currentTimestamp4,
   deleteEntrySchema,
   entryFileSchema,
   entrySchema,
-  fileTypeSchema as fileTypeSchema5,
-  getValueSchemaFromDefinition as getValueSchemaFromDefinition2,
+  getValueContentSchemaFromDefinition,
   listEntriesSchema,
+  objectTypeSchema as objectTypeSchema5,
   readEntrySchema,
   serviceTypeSchema as serviceTypeSchema6,
   updateEntrySchema,
@@ -1396,100 +1400,109 @@ import {
 } from "@elek-io/shared";
 import Fs6 from "fs-extra";
 
-// src/service/ValueService.ts
+// src/service/SharedValueService.ts
 import {
+  ValueTypeSchema,
   countValuesSchema,
-  createValueSchema,
+  createSharedValueSchema,
   currentTimestamp as currentTimestamp3,
-  deleteValueSchema,
-  fileTypeSchema as fileTypeSchema4,
-  getValueSchemaFromDefinition,
-  listValuesSchema,
-  readValueSchema,
+  deleteSharedValueSchema,
+  listSharedValuesSchema,
+  objectTypeSchema as objectTypeSchema4,
+  readSharedValueSchema,
   serviceTypeSchema as serviceTypeSchema5,
-  updateValueSchema,
+  sharedValueFileSchema,
+  sharedValueSchema,
+  updateSharedValueSchema,
   uuid as uuid4,
-  validateValueSchema,
-  valueFileSchema
+  z
 } from "@elek-io/shared";
 import Fs5 from "fs-extra";
-var ValueService = class extends AbstractCrudService {
+var SharedValueService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService, assetService) {
     super(serviceTypeSchema5.Enum.Value, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
   }
   /**
-   * Creates a new Value
+   * Creates a new shared Value
    */
   async create(props) {
-    createValueSchema.parse(props);
+    createSharedValueSchema.parse(props);
     const id = uuid4();
     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: currentTimestamp3()
     };
+    this.validate(sharedValueFile);
     await this.jsonFileService.create(
-      valueFile,
-      valueFilePath,
-      valueFileSchema
+      sharedValueFile,
+      sharedValueFilePath,
+      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) {
-    readValueSchema.parse(props);
-    const valueFile = await this.jsonFileService.read(
-      pathTo.valueFile(props.projectId, props.id, props.language),
-      valueFileSchema
+    readSharedValueSchema.parse(props);
+    const sharedValueFile = await this.jsonFileService.read(
+      pathTo.sharedValueFile(
+        props.projectId,
+        props.id,
+        props.language
+      ),
+      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) {
-    updateValueSchema.parse(props);
+    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: currentTimestamp3()
     };
+    this.validate(sharedValueFile);
     await this.jsonFileService.update(
-      valueFile,
-      valueFilePath,
-      valueFileSchema
+      sharedValueFile,
+      sharedValueFilePath,
+      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) {
-    deleteValueSchema.parse(props);
+    deleteSharedValueSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.valueFile(
+    const valueFilePath = pathTo.sharedValueFile(
       props.projectId,
       props.id,
       props.language
@@ -1499,9 +1512,9 @@ var ValueService = class extends AbstractCrudService {
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
-    listValuesSchema.parse(props);
+    listSharedValuesSchema.parse(props);
     const references = await this.listReferences(
-      fileTypeSchema4.Enum.value,
+      objectTypeSchema4.Enum.sharedValue,
       props.projectId
     );
     const list = await returnResolved(
@@ -1526,37 +1539,52 @@ var ValueService = class extends AbstractCrudService {
   }
   async count(props) {
     countValuesSchema.parse(props);
-    const count = (await this.listReferences(fileTypeSchema4.Enum.value, props.projectId)).length;
+    const count = (await this.listReferences(
+      objectTypeSchema4.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 valueFileSchema.safeParse(obj).success;
+  isSharedValue(obj) {
+    return 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) {
-    validateValueSchema.parse(props);
-    const value = await this.read(props);
-    const valueSchema = getValueSchemaFromDefinition(props.definition);
-    return valueSchema.safeParse(value.content);
+  validate(sharedValue) {
+    switch (sharedValue.valueType) {
+      case ValueTypeSchema.Enum.boolean:
+        z.boolean().parse(sharedValue.content);
+        break;
+      case ValueTypeSchema.Enum.number:
+        z.number().parse(sharedValue.content);
+        break;
+      case ValueTypeSchema.Enum.string:
+        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(serviceTypeSchema6.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) {
     createEntrySchema.parse(props);
@@ -1572,19 +1600,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: currentTimestamp4()
     };
+    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,
@@ -1592,10 +1623,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) {
     readEntrySchema.parse(props);
@@ -1608,10 +1639,10 @@ var EntryService = class extends AbstractCrudService {
       ),
       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) {
     updateEntrySchema.parse(props);
@@ -1626,12 +1657,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,
@@ -1640,9 +1665,18 @@ var EntryService = class extends AbstractCrudService {
     });
     const entryFile = {
       ...prevEntryFile,
-      valueReferences: props.valueReferences,
+      values: props.values,
       updated: currentTimestamp4()
     };
+    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,
@@ -1650,10 +1684,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) {
     deleteEntrySchema.parse(props);
@@ -1671,7 +1705,7 @@ var EntryService = class extends AbstractCrudService {
   async list(props) {
     listEntriesSchema.parse(props);
     const references = await this.listReferences(
-      fileTypeSchema5.Enum.entry,
+      objectTypeSchema5.Enum.entry,
       props.projectId,
       props.collectionId
     );
@@ -1699,45 +1733,147 @@ var EntryService = class extends AbstractCrudService {
   async count(props) {
     countEntriesSchema.parse(props);
     return (await this.listReferences(
-      fileTypeSchema5.Enum.entry,
+      objectTypeSchema5.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 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 = 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 objectTypeSchema5.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 = getValueSchemaFromDefinition2(definition);
-        const value = await this.valueService.read({
-          ...reference.references,
-          projectId
+      case objectTypeSchema5.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 === ValueTypeSchema2.Enum.reference) {
+            const resolvedValueContentReference = await this.resolveValueContentReference({
+              projectId: props.projectId,
+              valueContentReference: value.content
+            });
+            return {
+              ...value,
+              content: resolvedValueContentReference
+            };
+          }
+          return value;
+        })
+      )
+    };
+    return entry;
   }
 };
 
@@ -1746,9 +1882,9 @@ import {
   createProjectSchema,
   currentTimestamp as currentTimestamp5,
   deleteProjectSchema,
-  fileTypeSchema as fileTypeSchema6,
   gitCommitIconSchema as gitCommitIconSchema2,
   listProjectsSchema,
+  objectTypeSchema as objectTypeSchema6,
   projectFileSchema,
   projectFolderSchema as projectFolderSchema2,
   readProjectSchema,
@@ -1788,7 +1924,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 === "") {
@@ -1801,7 +1937,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)) {
@@ -1841,7 +1977,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(serviceTypeSchema8.Enum.Project, options);
     this.jsonFileService = jsonFileService;
     this.userService = userService;
@@ -1850,7 +1986,6 @@ var ProjectService = class extends AbstractCrudService {
     this.assetService = assetService;
     this.collectionService = collectionService;
     this.entryService = entryService;
-    this.valueService = valueService;
   }
   /**
    * Creates a new Project
@@ -1863,14 +1998,14 @@ var ProjectService = class extends AbstractCrudService {
     }
     const id = uuid6();
     const defaultSettings = {
-      locale: {
-        default: user.locale,
-        supported: [user.locale]
+      language: {
+        default: user.language,
+        supported: [user.language]
       }
     };
     const projectFile = {
       ...props,
-      fileType: "project",
+      objectType: "project",
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
@@ -2015,7 +2150,7 @@ var ProjectService = class extends AbstractCrudService {
     if (props) {
       listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(fileTypeSchema6.Enum.project);
+    const references = await this.listReferences(objectTypeSchema6.Enum.project);
     const list = await returnResolved(
       references.map((reference) => {
         return this.read({ id: reference.id });
@@ -2030,7 +2165,7 @@ var ProjectService = class extends AbstractCrudService {
     );
   }
   async count() {
-    return (await this.listReferences(fileTypeSchema6.Enum.project)).length;
+    return (await this.listReferences(objectTypeSchema6.Enum.project)).length;
   }
   /**
    * Search all models inside the project for given query
@@ -2051,6 +2186,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
    */
@@ -2065,26 +2201,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
         };
       })
     );
@@ -2154,23 +2273,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,
@@ -2185,8 +2305,7 @@ var ElekIoCore = class {
       this.searchService,
       this.assetService,
       this.collectionService,
-      this.entryService,
-      this.valueService
+      this.entryService
     );
     if (this.options.environment !== "production") {
       console.info(
@@ -2239,8 +2358,8 @@ var ElekIoCore = class {
   /**
    * CRUD methods to work with Values
    */
-  get values() {
-    return this.valueService;
+  get sharedValues() {
+    return this.sharedValueService;
   }
 };
 export {