@elek-io/core 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -33,8 +33,8 @@ __export(src_exports, {
   default: () => ElekIoCore
 });
 module.exports = __toCommonJS(src_exports);
-var import_shared13 = require("@elek-io/shared");
-var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+var import_shared12 = require("@elek-io/shared");
+var import_fs_extra7 = __toESM(require("fs-extra"), 1);
 
 // src/service/AssetService.ts
 var import_shared7 = require("@elek-io/shared");
@@ -107,11 +107,8 @@ var pathTo = {
   entries: (projectId, collectionId) => {
     return import_path.default.join(pathTo.collection(projectId, collectionId));
   },
-  entryFile: (projectId, collectionId, id, language) => {
-    return import_path.default.join(
-      pathTo.entries(projectId, collectionId),
-      `${id}.${language}.json`
-    );
+  entryFile: (projectId, collectionId, id) => {
+    return import_path.default.join(pathTo.entries(projectId, collectionId), `${id}.json`);
   },
   sharedValues: (projectId) => {
     return import_path.default.join(pathTo.project(projectId), "shared-values");
@@ -1357,189 +1354,28 @@ var CollectionService = class extends AbstractCrudService {
 };
 
 // src/service/EntryService.ts
-var import_shared10 = require("@elek-io/shared");
-var import_fs_extra6 = __toESM(require("fs-extra"), 1);
-
-// src/service/SharedValueService.ts
 var import_shared9 = require("@elek-io/shared");
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
-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 shared Value
-   */
-  async create(props) {
-    import_shared9.createSharedValueSchema.parse(props);
-    const id = (0, import_shared9.uuid)();
-    const projectPath = pathTo.project(props.projectId);
-    const sharedValueFilePath = pathTo.sharedValueFile(
-      props.projectId,
-      id,
-      props.language
-    );
-    const sharedValueFile = {
-      ...props,
-      objectType: "sharedValue",
-      id,
-      created: (0, import_shared9.currentTimestamp)()
-    };
-    this.validate(sharedValueFile);
-    await this.jsonFileService.create(
-      sharedValueFile,
-      sharedValueFilePath,
-      import_shared9.sharedValueFileSchema
-    );
-    await this.gitService.add(projectPath, [sharedValueFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return sharedValueFile;
-  }
-  /**
-   * Returns a shared Value by ID and language
-   */
-  async read(props) {
-    import_shared9.readSharedValueSchema.parse(props);
-    const sharedValueFile = await this.jsonFileService.read(
-      pathTo.sharedValueFile(
-        props.projectId,
-        props.id,
-        props.language
-      ),
-      import_shared9.sharedValueFileSchema
-    );
-    return sharedValueFile;
-  }
-  /**
-   * Updates given shared Values content
-   *
-   * The valueType cannot be changed after creating the shared Value
-   */
-  async update(props) {
-    import_shared9.updateSharedValueSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const sharedValueFilePath = pathTo.sharedValueFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    const prevSharedValueFile = await this.read(props);
-    const sharedValueFile = {
-      ...prevSharedValueFile,
-      content: props.content,
-      updated: (0, import_shared9.currentTimestamp)()
-    };
-    this.validate(sharedValueFile);
-    await this.jsonFileService.update(
-      sharedValueFile,
-      sharedValueFilePath,
-      import_shared9.sharedValueFileSchema
-    );
-    await this.gitService.add(projectPath, [sharedValueFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return sharedValueFile;
-  }
-  /**
-   * Deletes given shared Value
-   */
-  async delete(props) {
-    import_shared9.deleteSharedValueSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.sharedValueFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    await import_fs_extra5.default.remove(valueFilePath);
-    await this.gitService.add(projectPath, [valueFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    import_shared9.listSharedValuesSchema.parse(props);
-    const references = await this.listReferences(
-      import_shared9.objectTypeSchema.Enum.sharedValue,
-      props.projectId
-    );
-    const list = await returnResolved(
-      references.map((reference) => {
-        if (!reference.language) {
-          throw new RequiredParameterMissingError("language");
-        }
-        return this.read({
-          projectId: props.projectId,
-          id: reference.id,
-          language: reference.language
-        });
-      })
-    );
-    return this.paginate(
-      list,
-      props.sort,
-      props.filter,
-      props.limit,
-      props.offset
-    );
-  }
-  async count(props) {
-    import_shared9.countValuesSchema.parse(props);
-    const count = (await this.listReferences(
-      import_shared9.objectTypeSchema.Enum.sharedValue,
-      props.projectId
-    )).length;
-    return count;
-  }
-  /**
-   * Checks if given object is a shared Value
-   */
-  isSharedValue(obj) {
-    return import_shared9.sharedValueSchema.safeParse(obj).success;
-  }
-  /**
-   * Reads the given shared Values content based on it's ValueType
-   */
-  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, assetService, sharedValueService) {
-    super(import_shared10.serviceTypeSchema.Enum.Entry, options);
+  // private sharedValueService: SharedValueService;
+  constructor(options, jsonFileService, gitService, collectionService, assetService) {
+    super(import_shared9.serviceTypeSchema.Enum.Entry, options);
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
     this.assetService = assetService;
-    this.sharedValueService = sharedValueService;
   }
   /**
    * Creates a new Entry for given Collection
    */
   async create(props) {
-    import_shared10.createEntrySchema.parse(props);
-    const id = (0, import_shared10.uuid)();
+    import_shared9.createEntrySchema.parse(props);
+    const id = (0, import_shared9.uuid)();
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
       props.collectionId,
-      id,
-      props.language
+      id
     );
     const collection = await this.collectionService.read({
       projectId: props.projectId,
@@ -1548,12 +1384,12 @@ var EntryService = class extends AbstractCrudService {
     const entryFile = {
       objectType: "entry",
       id,
-      language: props.language,
       values: props.values,
-      created: (0, import_shared10.currentTimestamp)()
+      created: (0, import_shared9.currentTimestamp)()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
+      collectionId: props.collectionId,
       entryFile
     });
     this.validateValues({
@@ -1564,7 +1400,7 @@ var EntryService = class extends AbstractCrudService {
     await this.jsonFileService.create(
       entryFile,
       entryFilePath,
-      import_shared10.entryFileSchema
+      import_shared9.entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.create);
@@ -1574,29 +1410,27 @@ var EntryService = class extends AbstractCrudService {
    * Returns an Entry from given Collection by ID and language
    */
   async read(props) {
-    import_shared10.readEntrySchema.parse(props);
+    import_shared9.readEntrySchema.parse(props);
     const entryFile = await this.jsonFileService.read(
-      pathTo.entryFile(
-        props.projectId,
-        props.collectionId,
-        props.id,
-        props.language
-      ),
-      import_shared10.entryFileSchema
+      pathTo.entryFile(props.projectId, props.collectionId, props.id),
+      import_shared9.entryFileSchema
     );
-    return await this.toEntry({ projectId: props.projectId, entryFile });
+    return await this.toEntry({
+      projectId: props.projectId,
+      collectionId: props.collectionId,
+      entryFile
+    });
   }
   /**
    * Updates an Entry of given Collection with new Values and shared Values
    */
   async update(props) {
-    import_shared10.updateEntrySchema.parse(props);
+    import_shared9.updateEntrySchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
       props.collectionId,
-      props.id,
-      props.language
+      props.id
     );
     const collection = await this.collectionService.read({
       projectId: props.projectId,
@@ -1605,16 +1439,16 @@ var EntryService = class extends AbstractCrudService {
     const prevEntryFile = await this.read({
       projectId: props.projectId,
       collectionId: props.collectionId,
-      id: props.id,
-      language: props.language
+      id: props.id
     });
     const entryFile = {
       ...prevEntryFile,
       values: props.values,
-      updated: (0, import_shared10.currentTimestamp)()
+      updated: (0, import_shared9.currentTimestamp)()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
+      collectionId: props.collectionId,
       entryFile
     });
     this.validateValues({
@@ -1625,7 +1459,7 @@ var EntryService = class extends AbstractCrudService {
     await this.jsonFileService.update(
       entryFile,
       entryFilePath,
-      import_shared10.entryFileSchema
+      import_shared9.entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
@@ -1635,35 +1469,30 @@ var EntryService = class extends AbstractCrudService {
    * Deletes given Entry from it's Collection
    */
   async delete(props) {
-    import_shared10.deleteEntrySchema.parse(props);
+    import_shared9.deleteEntrySchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
     const entryFilePath = pathTo.entryFile(
       props.projectId,
       props.collectionId,
-      props.id,
-      props.language
+      props.id
     );
-    await import_fs_extra6.default.remove(entryFilePath);
+    await import_fs_extra5.default.remove(entryFilePath);
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
-    import_shared10.listEntriesSchema.parse(props);
+    import_shared9.listEntriesSchema.parse(props);
     const references = await this.listReferences(
-      import_shared10.objectTypeSchema.Enum.entry,
+      import_shared9.objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     );
     const list = await returnResolved(
       references.map((reference) => {
-        if (!reference.language) {
-          throw new RequiredParameterMissingError("language");
-        }
         return this.read({
           projectId: props.projectId,
           collectionId: props.collectionId,
-          id: reference.id,
-          language: reference.language
+          id: reference.id
         });
       })
     );
@@ -1676,9 +1505,9 @@ var EntryService = class extends AbstractCrudService {
     );
   }
   async count(props) {
-    import_shared10.countEntriesSchema.parse(props);
+    import_shared9.countEntriesSchema.parse(props);
     return (await this.listReferences(
-      import_shared10.objectTypeSchema.Enum.entry,
+      import_shared9.objectTypeSchema.Enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -1687,7 +1516,7 @@ var EntryService = class extends AbstractCrudService {
    * Checks if given object is of type Entry
    */
   isEntry(obj) {
-    return import_shared10.entrySchema.safeParse(obj).success;
+    return import_shared9.entrySchema.safeParse(obj).success;
   }
   /**
    * Returns a Value definition by ID
@@ -1716,9 +1545,15 @@ var EntryService = class extends AbstractCrudService {
         valueDefinitions: props.valueDefinitions,
         id: value.definitionId
       });
-      const schema = (0, import_shared10.getValueContentSchemaFromDefinition)(definition);
+      const schema = (0, import_shared9.getValueContentSchemaFromDefinition)(definition);
       try {
-        schema.parse(value.content);
+        if (value.valueType === "reference") {
+          schema.parse(value.content);
+        } else {
+          for (const [language, content] of Object.entries(value.content)) {
+            schema.parse(content);
+          }
+        }
       } catch (error) {
         console.log("Definition:", definition);
         console.log("Value:", value);
@@ -1746,15 +1581,16 @@ var EntryService = class extends AbstractCrudService {
   // }
   async resolveValueContentReference(props) {
     switch (props.valueContentReference.referenceObjectType) {
-      case import_shared10.objectTypeSchema.Enum.asset:
+      case import_shared9.objectTypeSchema.Enum.asset:
         return this.resolveValueContentReferenceToAsset({
           projectId: props.projectId,
           valueContentReferenceToAsset: props.valueContentReference
         });
-      case import_shared10.objectTypeSchema.Enum.sharedValue:
-        return this.resolveValueContentReferenceToSharedValue({
+      case import_shared9.objectTypeSchema.Enum.entry:
+        return this.resolveValueContentReferenceToEntry({
           projectId: props.projectId,
-          valueContentReferenceToSharedValue: props.valueContentReference
+          collectionId: props.collectionId,
+          valueContentReferenceToEntry: props.valueContentReference
         });
       default:
         throw new Error(
@@ -1771,10 +1607,7 @@ var EntryService = class extends AbstractCrudService {
           id: reference.id,
           language: reference.language
         });
-        return {
-          ...reference,
-          resolved: resolvedAsset
-        };
+        return resolvedAsset;
       })
     );
     return {
@@ -1782,20 +1615,39 @@ var EntryService = class extends AbstractCrudService {
       references: resolvedReferences
     };
   }
-  async resolveValueContentReferenceToSharedValue(props) {
-    const resolvedSharedValue = await this.sharedValueService.read({
-      projectId: props.projectId,
-      id: props.valueContentReferenceToSharedValue.references.id,
-      language: props.valueContentReferenceToSharedValue.references.language
-    });
+  async resolveValueContentReferenceToEntry(props) {
+    const resolvedReferences = await Promise.all(
+      props.valueContentReferenceToEntry.references.map(async (reference) => {
+        const resolvedEntry = await this.read({
+          projectId: props.projectId,
+          collectionId: props.collectionId,
+          id: reference.id
+        });
+        return resolvedEntry;
+      })
+    );
     return {
-      ...props.valueContentReferenceToSharedValue,
-      references: {
-        ...props.valueContentReferenceToSharedValue.references,
-        resolved: resolvedSharedValue
-      }
+      ...props.valueContentReferenceToEntry,
+      references: resolvedReferences
     };
   }
+  // private async resolveValueContentReferenceToSharedValue(props: {
+  //   projectId: string;
+  //   valueContentReferenceToSharedValue: ValueContentReferenceToSharedValue;
+  // }): Promise<ResolvedValueContentReferenceToSharedValue> {
+  //   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
    */
@@ -1804,9 +1656,10 @@ var EntryService = class extends AbstractCrudService {
       ...props.entryFile,
       values: await Promise.all(
         props.entryFile.values.map(async (value) => {
-          if (value.valueType === import_shared10.ValueTypeSchema.Enum.reference) {
+          if (value.valueType === import_shared9.ValueTypeSchema.Enum.reference) {
             const resolvedValueContentReference = await this.resolveValueContentReference({
               projectId: props.projectId,
+              collectionId: props.collectionId,
               valueContentReference: value.content
             });
             return {
@@ -1823,8 +1676,8 @@ var EntryService = class extends AbstractCrudService {
 };
 
 // src/service/ProjectService.ts
-var import_shared12 = require("@elek-io/shared");
-var import_fs_extra7 = __toESM(require("fs-extra"), 1);
+var import_shared11 = require("@elek-io/shared");
+var import_fs_extra6 = __toESM(require("fs-extra"), 1);
 var import_os2 = __toESM(require("os"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_semver = __toESM(require("semver"), 1);
@@ -1838,10 +1691,10 @@ var ProjectUpgradeError = class extends Error {
 };
 
 // src/service/SearchService.ts
-var import_shared11 = require("@elek-io/shared");
+var import_shared10 = require("@elek-io/shared");
 var SearchService = class extends AbstractCrudService {
   constructor(options, assetService, collectionService) {
-    super(import_shared11.serviceTypeSchema.enum.Search, options);
+    super(import_shared10.serviceTypeSchema.enum.Search, options);
     this.assetService = assetService;
     this.collectionService = collectionService;
   }
@@ -1907,7 +1760,7 @@ var SearchService = class extends AbstractCrudService {
 // src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
   constructor(options, jsonFileService, userService, gitService, searchService, assetService, collectionService, entryService) {
-    super(import_shared12.serviceTypeSchema.Enum.Project, options);
+    super(import_shared11.serviceTypeSchema.Enum.Project, options);
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
@@ -1920,16 +1773,16 @@ var ProjectService = class extends AbstractCrudService {
    * Creates a new Project
    */
   async create(props) {
-    import_shared12.createProjectSchema.parse(props);
+    import_shared11.createProjectSchema.parse(props);
     const user = await this.userService.get();
     if (!user) {
       throw new NoCurrentUserError();
     }
-    const id = (0, import_shared12.uuid)();
+    const id = (0, import_shared11.uuid)();
     const defaultSettings = {
-      locale: {
-        default: user.locale,
-        supported: [user.locale]
+      language: {
+        default: user.language,
+        supported: [user.language]
       }
     };
     const projectFile = {
@@ -1938,14 +1791,14 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: (0, import_shared12.currentTimestamp)(),
+      created: (0, import_shared11.currentTimestamp)(),
       coreVersion: this.options.version,
       // @todo should be read from package.json to avoid duplicates
       status: "todo",
       version: "0.0.1"
     };
     const projectPath = pathTo.project(id);
-    await import_fs_extra7.default.ensureDir(projectPath);
+    await import_fs_extra6.default.ensureDir(projectPath);
     try {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
@@ -1953,12 +1806,12 @@ var ProjectService = class extends AbstractCrudService {
       await this.jsonFileService.create(
         projectFile,
         pathTo.projectFile(id),
-        import_shared12.projectFileSchema
+        import_shared11.projectFileSchema
       );
       await this.gitService.add(projectPath, ["."]);
       await this.gitService.commit(
         projectPath,
-        `${import_shared12.gitCommitIconSchema.enum.INIT} Created this new elek.io project`
+        `${import_shared11.gitCommitIconSchema.enum.INIT} Created this new elek.io project`
       );
       await this.gitService.switch(projectPath, "stage", { isNew: true });
     } catch (error) {
@@ -1973,10 +1826,10 @@ var ProjectService = class extends AbstractCrudService {
    * Returns a Project by ID
    */
   async read(props) {
-    import_shared12.readProjectSchema.parse(props);
+    import_shared11.readProjectSchema.parse(props);
     const projectFile = await this.jsonFileService.read(
       pathTo.projectFile(props.id),
-      import_shared12.projectFileSchema
+      import_shared11.projectFileSchema
     );
     return projectFile;
   }
@@ -1984,16 +1837,16 @@ var ProjectService = class extends AbstractCrudService {
    * Updates given Project
    */
   async update(props) {
-    import_shared12.updateProjectSchema.parse(props);
+    import_shared11.updateProjectSchema.parse(props);
     const projectPath = pathTo.project(props.id);
     const filePath = pathTo.projectFile(props.id);
     const prevProjectFile = await this.read(props);
     const projectFile = {
       ...prevProjectFile,
       ...props,
-      updated: (0, import_shared12.currentTimestamp)()
+      updated: (0, import_shared11.currentTimestamp)()
     };
-    await this.jsonFileService.update(projectFile, filePath, import_shared12.projectFileSchema);
+    await this.jsonFileService.update(projectFile, filePath, import_shared11.projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
     await this.gitService.commit(projectPath, this.gitMessage.update);
     return projectFile;
@@ -2006,7 +1859,7 @@ var ProjectService = class extends AbstractCrudService {
    * @todo Find out why using this.snapshotService is throwing isObjWithKeyAndValueOfString of undefined error in gitService (maybe binding issue)
    */
   async upgrade(props) {
-    import_shared12.upgradeProjectSchema.parse(props);
+    import_shared11.upgradeProjectSchema.parse(props);
     const project = await this.read(props);
     const projectPath = pathTo.project(project.id);
     if (import_semver.default.gt(project.coreVersion, this.options.version)) {
@@ -2072,14 +1925,14 @@ var ProjectService = class extends AbstractCrudService {
    * Or changes that are not pushed to a remote yet, will be lost too.
    */
   async delete(props) {
-    import_shared12.deleteProjectSchema.parse(props);
-    await import_fs_extra7.default.remove(pathTo.project(props.id));
+    import_shared11.deleteProjectSchema.parse(props);
+    await import_fs_extra6.default.remove(pathTo.project(props.id));
   }
   async list(props) {
     if (props) {
-      import_shared12.listProjectsSchema.parse(props);
+      import_shared11.listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(import_shared12.objectTypeSchema.Enum.project);
+    const references = await this.listReferences(import_shared11.objectTypeSchema.Enum.project);
     const list = await returnResolved(
       references.map((reference) => {
         return this.read({ id: reference.id });
@@ -2094,7 +1947,7 @@ var ProjectService = class extends AbstractCrudService {
     );
   }
   async count() {
-    return (await this.listReferences(import_shared12.objectTypeSchema.Enum.project)).length;
+    return (await this.listReferences(import_shared11.objectTypeSchema.Enum.project)).length;
   }
   /**
    * Search all models inside the project for given query
@@ -2110,7 +1963,7 @@ var ProjectService = class extends AbstractCrudService {
    * Checks if given object is of type Project
    */
   isProject(obj) {
-    return import_shared12.projectFileSchema.safeParse(obj).success;
+    return import_shared11.projectFileSchema.safeParse(obj).success;
   }
   /**
    * Exports given Project to JSON
@@ -2148,11 +2001,11 @@ var ProjectService = class extends AbstractCrudService {
    * committed
    */
   async createFolderStructure(path) {
-    const folders2 = Object.values(import_shared12.projectFolderSchema.Values);
+    const folders2 = Object.values(import_shared11.projectFolderSchema.Values);
     await Promise.all(
       folders2.map(async (folder) => {
-        await import_fs_extra7.default.mkdirp(import_path2.default.join(path, folder));
-        await import_fs_extra7.default.writeFile(import_path2.default.join(path, folder, ".gitkeep"), "");
+        await import_fs_extra6.default.mkdirp(import_path2.default.join(path, folder));
+        await import_fs_extra6.default.writeFile(import_path2.default.join(path, folder, ".gitkeep"), "");
       })
     );
   }
@@ -2176,14 +2029,15 @@ var ProjectService = class extends AbstractCrudService {
       // projectFolderSchema.Enum.public + '/',
       // projectFolderSchema.Enum.logs + '/',
     ];
-    await import_fs_extra7.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os2.default.EOL));
+    await import_fs_extra6.default.writeFile(import_path2.default.join(path, ".gitignore"), lines.join(import_os2.default.EOL));
   }
 };
 
 // src/index.ts
 var ElekIoCore = class {
+  // private readonly sharedValueService: SharedValueService;
   constructor(props) {
-    const parsedProps = import_shared13.constructorElekIoCoreSchema.parse(props);
+    const parsedProps = import_shared12.constructorElekIoCoreSchema.parse(props);
     const defaults = {
       environment: "production",
       version: "0.0.0",
@@ -2207,19 +2061,13 @@ var ElekIoCore = class {
       this.jsonFileService,
       this.gitService
     );
-    this.sharedValueService = new SharedValueService(
-      this.options,
-      this.jsonFileService,
-      this.gitService,
-      this.assetService
-    );
     this.entryService = new EntryService(
       this.options,
       this.jsonFileService,
       this.gitService,
       this.collectionService,
-      this.assetService,
-      this.sharedValueService
+      this.assetService
+      // this.sharedValueService
     );
     this.searchService = new SearchService(
       this.options,
@@ -2244,9 +2092,9 @@ var ElekIoCore = class {
         }
       );
     }
-    import_fs_extra8.default.mkdirpSync(pathTo.projects);
-    import_fs_extra8.default.mkdirpSync(pathTo.tmp);
-    import_fs_extra8.default.emptyDirSync(pathTo.tmp);
+    import_fs_extra7.default.mkdirpSync(pathTo.projects);
+    import_fs_extra7.default.mkdirpSync(pathTo.tmp);
+    import_fs_extra7.default.emptyDirSync(pathTo.tmp);
   }
   /**
    * Utility / helper functions
@@ -2287,8 +2135,8 @@ var ElekIoCore = class {
   /**
    * CRUD methods to work with Values
    */
-  get sharedValues() {
-    return this.sharedValueService;
-  }
+  // public get sharedValues(): SharedValueService {
+  //   return this.sharedValueService;
+  // }
 };
 //# sourceMappingURL=index.cjs.map