@elek-io/core 0.2.1 → 0.3.0

package/dist/index.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 import {
   constructorElekIoCoreSchema
 } from "@elek-io/shared";
-import Fs8 from "fs-extra";
+import Fs7 from "fs-extra";
 
 // src/service/AssetService.ts
 import {
@@ -97,11 +97,8 @@ var pathTo = {
   entries: (projectId, collectionId) => {
     return Path.join(pathTo.collection(projectId, collectionId));
   },
-  entryFile: (projectId, collectionId, id, language) => {
-    return Path.join(
-      pathTo.entries(projectId, collectionId),
-      `${id}.${language}.json`
-    );
+  entryFile: (projectId, collectionId, id) => {
+    return Path.join(pathTo.entries(projectId, collectionId), `${id}.json`);
   },
   sharedValues: (projectId) => {
     return Path.join(pathTo.project(projectId), "shared-values");
@@ -1383,218 +1380,42 @@ var CollectionService = class extends AbstractCrudService {
 
 // src/service/EntryService.ts
 import {
-  ValueTypeSchema as ValueTypeSchema2,
+  ValueTypeSchema,
   countEntriesSchema,
   createEntrySchema,
-  currentTimestamp as currentTimestamp4,
+  currentTimestamp as currentTimestamp3,
   deleteEntrySchema,
   entryFileSchema,
   entrySchema,
   getValueContentSchemaFromDefinition,
   listEntriesSchema,
-  objectTypeSchema as objectTypeSchema5,
-  readEntrySchema,
-  serviceTypeSchema as serviceTypeSchema6,
-  updateEntrySchema,
-  uuid as uuid5
-} from "@elek-io/shared";
-import Fs6 from "fs-extra";
-
-// src/service/SharedValueService.ts
-import {
-  ValueTypeSchema,
-  countValuesSchema,
-  createSharedValueSchema,
-  currentTimestamp as currentTimestamp3,
-  deleteSharedValueSchema,
-  listSharedValuesSchema,
   objectTypeSchema as objectTypeSchema4,
-  readSharedValueSchema,
+  readEntrySchema,
   serviceTypeSchema as serviceTypeSchema5,
-  sharedValueFileSchema,
-  sharedValueSchema,
-  updateSharedValueSchema,
-  uuid as uuid4,
-  z
+  updateEntrySchema,
+  uuid as uuid4
 } from "@elek-io/shared";
 import Fs5 from "fs-extra";
-var SharedValueService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService, assetService) {
-    super(serviceTypeSchema5.Enum.Value, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
-  }
-  /**
-   * Creates a new shared Value
-   */
-  async create(props) {
-    createSharedValueSchema.parse(props);
-    const id = uuid4();
-    const projectPath = pathTo.project(props.projectId);
-    const sharedValueFilePath = pathTo.sharedValueFile(
-      props.projectId,
-      id,
-      props.language
-    );
-    const sharedValueFile = {
-      ...props,
-      objectType: "sharedValue",
-      id,
-      created: currentTimestamp3()
-    };
-    this.validate(sharedValueFile);
-    await this.jsonFileService.create(
-      sharedValueFile,
-      sharedValueFilePath,
-      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) {
-    readSharedValueSchema.parse(props);
-    const sharedValueFile = await this.jsonFileService.read(
-      pathTo.sharedValueFile(
-        props.projectId,
-        props.id,
-        props.language
-      ),
-      sharedValueFileSchema
-    );
-    return sharedValueFile;
-  }
-  /**
-   * Updates given shared Values content
-   *
-   * The valueType cannot be changed after creating the shared Value
-   */
-  async update(props) {
-    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: currentTimestamp3()
-    };
-    this.validate(sharedValueFile);
-    await this.jsonFileService.update(
-      sharedValueFile,
-      sharedValueFilePath,
-      sharedValueFileSchema
-    );
-    await this.gitService.add(projectPath, [sharedValueFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return sharedValueFile;
-  }
-  /**
-   * Deletes given shared Value
-   */
-  async delete(props) {
-    deleteSharedValueSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const valueFilePath = pathTo.sharedValueFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    await Fs5.remove(valueFilePath);
-    await this.gitService.add(projectPath, [valueFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
-  }
-  async list(props) {
-    listSharedValuesSchema.parse(props);
-    const references = await this.listReferences(
-      objectTypeSchema4.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) {
-    countValuesSchema.parse(props);
-    const count = (await this.listReferences(
-      objectTypeSchema4.Enum.sharedValue,
-      props.projectId
-    )).length;
-    return count;
-  }
-  /**
-   * Checks if given object is a shared Value
-   */
-  isSharedValue(obj) {
-    return sharedValueSchema.safeParse(obj).success;
-  }
-  /**
-   * Reads the given shared Values content based on it's ValueType
-   */
-  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, assetService, sharedValueService) {
-    super(serviceTypeSchema6.Enum.Entry, options);
+  // private sharedValueService: SharedValueService;
+  constructor(options, jsonFileService, gitService, collectionService, assetService) {
+    super(serviceTypeSchema5.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) {
     createEntrySchema.parse(props);
-    const id = uuid5();
+    const id = uuid4();
     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,
@@ -1603,12 +1424,12 @@ var EntryService = class extends AbstractCrudService {
     const entryFile = {
       objectType: "entry",
       id,
-      language: props.language,
       values: props.values,
-      created: currentTimestamp4()
+      created: currentTimestamp3()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
+      collectionId: props.collectionId,
       entryFile
     });
     this.validateValues({
@@ -1631,15 +1452,14 @@ var EntryService = class extends AbstractCrudService {
   async read(props) {
     readEntrySchema.parse(props);
     const entryFile = await this.jsonFileService.read(
-      pathTo.entryFile(
-        props.projectId,
-        props.collectionId,
-        props.id,
-        props.language
-      ),
+      pathTo.entryFile(props.projectId, props.collectionId, props.id),
       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
@@ -1650,8 +1470,7 @@ var EntryService = class extends AbstractCrudService {
     const entryFilePath = pathTo.entryFile(
       props.projectId,
       props.collectionId,
-      props.id,
-      props.language
+      props.id
     );
     const collection = await this.collectionService.read({
       projectId: props.projectId,
@@ -1660,16 +1479,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: currentTimestamp4()
+      updated: currentTimestamp3()
     };
     const entry = await this.toEntry({
       projectId: props.projectId,
+      collectionId: props.collectionId,
       entryFile
     });
     this.validateValues({
@@ -1695,30 +1514,25 @@ var EntryService = class extends AbstractCrudService {
     const entryFilePath = pathTo.entryFile(
       props.projectId,
       props.collectionId,
-      props.id,
-      props.language
+      props.id
     );
-    await Fs6.remove(entryFilePath);
+    await Fs5.remove(entryFilePath);
     await this.gitService.add(projectPath, [entryFilePath]);
     await this.gitService.commit(projectPath, this.gitMessage.delete);
   }
   async list(props) {
     listEntriesSchema.parse(props);
     const references = await this.listReferences(
-      objectTypeSchema5.Enum.entry,
+      objectTypeSchema4.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
         });
       })
     );
@@ -1733,7 +1547,7 @@ var EntryService = class extends AbstractCrudService {
   async count(props) {
     countEntriesSchema.parse(props);
     return (await this.listReferences(
-      objectTypeSchema5.Enum.entry,
+      objectTypeSchema4.Enum.entry,
       props.projectId,
       props.collectionId
     )).length;
@@ -1773,7 +1587,13 @@ var EntryService = class extends AbstractCrudService {
       });
       const schema = 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);
@@ -1801,15 +1621,16 @@ var EntryService = class extends AbstractCrudService {
   // }
   async resolveValueContentReference(props) {
     switch (props.valueContentReference.referenceObjectType) {
-      case objectTypeSchema5.Enum.asset:
+      case objectTypeSchema4.Enum.asset:
         return this.resolveValueContentReferenceToAsset({
           projectId: props.projectId,
           valueContentReferenceToAsset: props.valueContentReference
         });
-      case objectTypeSchema5.Enum.sharedValue:
-        return this.resolveValueContentReferenceToSharedValue({
+      case objectTypeSchema4.Enum.entry:
+        return this.resolveValueContentReferenceToEntry({
           projectId: props.projectId,
-          valueContentReferenceToSharedValue: props.valueContentReference
+          collectionId: props.collectionId,
+          valueContentReferenceToEntry: props.valueContentReference
         });
       default:
         throw new Error(
@@ -1826,10 +1647,7 @@ var EntryService = class extends AbstractCrudService {
           id: reference.id,
           language: reference.language
         });
-        return {
-          ...reference,
-          resolved: resolvedAsset
-        };
+        return resolvedAsset;
       })
     );
     return {
@@ -1837,20 +1655,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
    */
@@ -1859,9 +1696,10 @@ var EntryService = class extends AbstractCrudService {
       ...props.entryFile,
       values: await Promise.all(
         props.entryFile.values.map(async (value) => {
-          if (value.valueType === ValueTypeSchema2.Enum.reference) {
+          if (value.valueType === ValueTypeSchema.Enum.reference) {
             const resolvedValueContentReference = await this.resolveValueContentReference({
               projectId: props.projectId,
+              collectionId: props.collectionId,
               valueContentReference: value.content
             });
             return {
@@ -1880,20 +1718,20 @@ var EntryService = class extends AbstractCrudService {
 // src/service/ProjectService.ts
 import {
   createProjectSchema,
-  currentTimestamp as currentTimestamp5,
+  currentTimestamp as currentTimestamp4,
   deleteProjectSchema,
   gitCommitIconSchema as gitCommitIconSchema2,
   listProjectsSchema,
-  objectTypeSchema as objectTypeSchema6,
+  objectTypeSchema as objectTypeSchema5,
   projectFileSchema,
   projectFolderSchema as projectFolderSchema2,
   readProjectSchema,
-  serviceTypeSchema as serviceTypeSchema8,
+  serviceTypeSchema as serviceTypeSchema7,
   updateProjectSchema,
   upgradeProjectSchema,
-  uuid as uuid6
+  uuid as uuid5
 } from "@elek-io/shared";
-import Fs7 from "fs-extra";
+import Fs6 from "fs-extra";
 import Os2 from "os";
 import Path2 from "path";
 import Semver from "semver";
@@ -1908,11 +1746,11 @@ var ProjectUpgradeError = class extends Error {
 
 // src/service/SearchService.ts
 import {
-  serviceTypeSchema as serviceTypeSchema7
+  serviceTypeSchema as serviceTypeSchema6
 } from "@elek-io/shared";
 var SearchService = class extends AbstractCrudService {
   constructor(options, assetService, collectionService) {
-    super(serviceTypeSchema7.enum.Search, options);
+    super(serviceTypeSchema6.enum.Search, options);
     this.assetService = assetService;
     this.collectionService = collectionService;
   }
@@ -1978,7 +1816,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(serviceTypeSchema8.Enum.Project, options);
+    super(serviceTypeSchema7.Enum.Project, options);
     this.jsonFileService = jsonFileService;
     this.userService = userService;
     this.gitService = gitService;
@@ -1996,7 +1834,7 @@ var ProjectService = class extends AbstractCrudService {
     if (!user) {
       throw new NoCurrentUserError();
     }
-    const id = uuid6();
+    const id = uuid5();
     const defaultSettings = {
       language: {
         default: user.language,
@@ -2009,14 +1847,14 @@ var ProjectService = class extends AbstractCrudService {
       id,
       description: props.description || "",
       settings: Object.assign({}, defaultSettings, props.settings),
-      created: currentTimestamp5(),
+      created: currentTimestamp4(),
       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 Fs7.ensureDir(projectPath);
+    await Fs6.ensureDir(projectPath);
     try {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
@@ -2062,7 +1900,7 @@ var ProjectService = class extends AbstractCrudService {
     const projectFile = {
       ...prevProjectFile,
       ...props,
-      updated: currentTimestamp5()
+      updated: currentTimestamp4()
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
@@ -2144,13 +1982,13 @@ var ProjectService = class extends AbstractCrudService {
    */
   async delete(props) {
     deleteProjectSchema.parse(props);
-    await Fs7.remove(pathTo.project(props.id));
+    await Fs6.remove(pathTo.project(props.id));
   }
   async list(props) {
     if (props) {
       listProjectsSchema.parse(props);
     }
-    const references = await this.listReferences(objectTypeSchema6.Enum.project);
+    const references = await this.listReferences(objectTypeSchema5.Enum.project);
     const list = await returnResolved(
       references.map((reference) => {
         return this.read({ id: reference.id });
@@ -2165,7 +2003,7 @@ var ProjectService = class extends AbstractCrudService {
     );
   }
   async count() {
-    return (await this.listReferences(objectTypeSchema6.Enum.project)).length;
+    return (await this.listReferences(objectTypeSchema5.Enum.project)).length;
   }
   /**
    * Search all models inside the project for given query
@@ -2222,8 +2060,8 @@ var ProjectService = class extends AbstractCrudService {
     const folders2 = Object.values(projectFolderSchema2.Values);
     await Promise.all(
       folders2.map(async (folder) => {
-        await Fs7.mkdirp(Path2.join(path, folder));
-        await Fs7.writeFile(Path2.join(path, folder, ".gitkeep"), "");
+        await Fs6.mkdirp(Path2.join(path, folder));
+        await Fs6.writeFile(Path2.join(path, folder, ".gitkeep"), "");
       })
     );
   }
@@ -2247,12 +2085,13 @@ var ProjectService = class extends AbstractCrudService {
       // projectFolderSchema.Enum.public + '/',
       // projectFolderSchema.Enum.logs + '/',
     ];
-    await Fs7.writeFile(Path2.join(path, ".gitignore"), lines.join(Os2.EOL));
+    await Fs6.writeFile(Path2.join(path, ".gitignore"), lines.join(Os2.EOL));
   }
 };
 
 // src/index.ts
 var ElekIoCore = class {
+  // private readonly sharedValueService: SharedValueService;
   constructor(props) {
     const parsedProps = constructorElekIoCoreSchema.parse(props);
     const defaults = {
@@ -2278,19 +2117,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,
@@ -2315,9 +2148,9 @@ var ElekIoCore = class {
         }
       );
     }
-    Fs8.mkdirpSync(pathTo.projects);
-    Fs8.mkdirpSync(pathTo.tmp);
-    Fs8.emptyDirSync(pathTo.tmp);
+    Fs7.mkdirpSync(pathTo.projects);
+    Fs7.mkdirpSync(pathTo.tmp);
+    Fs7.emptyDirSync(pathTo.tmp);
   }
   /**
    * Utility / helper functions
@@ -2358,9 +2191,9 @@ var ElekIoCore = class {
   /**
    * CRUD methods to work with Values
    */
-  get sharedValues() {
-    return this.sharedValueService;
-  }
+  // public get sharedValues(): SharedValueService {
+  //   return this.sharedValueService;
+  // }
 };
 export {
   ElekIoCore as default