@elek-io/core 0.12.0 → 0.13.0

package/dist/node/index.node.js

@@ -8,19 +8,44 @@ var __export = (target, all) => {
 import Fs7 from "fs-extra";
 
 // package.json
-var version = "0.12.0";
+var version = "0.13.0";
 
 // src/api/index.ts
 import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
-import { OpenAPIHono as OpenAPIHono2 } from "@hono/zod-openapi";
+import { OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
 import { cors } from "hono/cors";
 
-// src/api/v1/projects.ts
+// src/api/middleware/logger.ts
+import { createMiddleware } from "hono/factory";
+var LoggerMiddleware = class {
+  logService;
+  constructor(logService) {
+    this.logService = logService;
+  }
+  handler = createMiddleware(async (c, next) => {
+    const { method, url } = c.req;
+    this.logService.info(`Recieved API request "${method} ${url}"`);
+    const start = Date.now();
+    await next();
+    const durationMs = Date.now() - start;
+    const statusCode = c.res.status.toString();
+    const resultLog = `Response for API request "${method} ${url}" with status code ${statusCode} in ${durationMs}ms`;
+    if (statusCode.startsWith("2")) {
+      this.logService.info(resultLog);
+    } else if (statusCode.startsWith("3")) {
+      this.logService.warn(resultLog);
+    } else if (statusCode.startsWith("4") || statusCode.startsWith("5")) {
+      this.logService.error(resultLog);
+    }
+  });
+};
+
+// src/api/v1/asset.ts
 import { createRoute, OpenAPIHono, z as z13 } from "@hono/zod-openapi";
 
 // src/schema/assetSchema.ts
-import z4 from "zod";
+import { z as z4 } from "@hono/zod-openapi";
 
 // src/schema/baseSchema.ts
 import z from "zod";
@@ -271,7 +296,7 @@ var assetSchema = assetFileSchema.extend({
    * Commit history of this Asset
    */
   history: z4.array(gitCommitSchema)
-});
+}).openapi("Asset");
 var assetExportSchema = assetSchema.extend({});
 var createAssetSchema = assetFileSchema.pick({
   name: true,
@@ -316,10 +341,10 @@ var deleteAssetSchema = assetFileSchema.pick({
 var countAssetsSchema = z4.object({ projectId: uuidSchema.readonly() });
 
 // src/schema/collectionSchema.ts
-import z8 from "zod";
+import { z as z8 } from "@hono/zod-openapi";
 
 // src/schema/entrySchema.ts
-import z6 from "zod";
+import { z as z6 } from "@hono/zod-openapi";
 
 // src/schema/valueSchema.ts
 import z5 from "zod";
@@ -347,12 +372,6 @@ var valueContentReferenceSchema = z5.union([
   valueContentReferenceToEntrySchema
   // valueContentReferenceToSharedValueSchema,
 ]);
-var resolvedValueContentReferenceSchema = z5.union([
-  assetSchema,
-  z5.lazy(() => entrySchema)
-  // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
-  // resolvedValueContentReferenceToSharedValueSchema,
-]);
 var directValueBaseSchema = z5.object({
   objectType: z5.literal(objectTypeSchema.Enum.value).readonly(),
   fieldDefinitionId: uuidSchema.readonly()
@@ -381,13 +400,6 @@ var referencedValueSchema = z5.object({
   content: translatableArrayOf(valueContentReferenceSchema)
 });
 var valueSchema = z5.union([directValueSchema, referencedValueSchema]);
-var resolvedReferencedValueSchema = referencedValueSchema.extend({
-  content: translatableArrayOf(resolvedValueContentReferenceSchema)
-});
-var resolvedValueSchema = z5.union([
-  directValueSchema,
-  resolvedReferencedValueSchema
-]);
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
@@ -395,12 +407,11 @@ var entryFileSchema = baseFileSchema.extend({
   values: z6.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
-  values: z6.array(z6.lazy(() => resolvedValueSchema)),
   /**
    * Commit history of this Entry
    */
   history: z6.array(gitCommitSchema)
-});
+}).openapi("Entry");
 var entryExportSchema = entrySchema.extend({});
 var createEntrySchema = entryFileSchema.omit({
   id: true,
@@ -694,7 +705,7 @@ var collectionSchema = collectionFileSchema.extend({
    * Commit history of this Collection
    */
   history: z8.array(gitCommitSchema)
-});
+}).openapi("Collection");
 var collectionExportSchema = collectionSchema.extend({
   entries: z8.array(entryExportSchema)
 });
@@ -899,14 +910,8 @@ function paginatedListOf(schema) {
 }
 var listSchema = z11.object({
   projectId: uuidSchema,
-  limit: z11.number().optional().openapi({
-    default: 15,
-    description: "The maximum number of items to return"
-  }),
-  offset: z11.number().optional().openapi({
-    default: 0,
-    description: "The number of items to skip before starting to collect the result set"
-  })
+  limit: z11.number().optional(),
+  offset: z11.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -956,57 +961,480 @@ var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
-// src/api/v1/projects.ts
-var ProjectsApiV1 = class {
+// src/api/v1/asset.ts
+var AssetApiV1 = class {
   api;
-  projectService;
-  constructor(projectService) {
-    this.projectService = projectService;
+  assetService;
+  constructor(assetService) {
+    this.assetService = assetService;
     this.api = new OpenAPIHono();
     this.registerRoutes();
   }
   registerRoutes() {
-    this.api.openapi(countProjectsRoute, async (context) => {
-      const count = await this.projectService.count();
+    this.api.openapi(listAssetsRoute, async (context) => {
+      const { projectId } = context.req.valid("param");
+      const { limit, offset } = context.req.valid("query");
+      const assets = await this.assetService.list({
+        projectId,
+        limit,
+        offset
+      });
+      return context.json(assets, 200);
+    });
+    this.api.openapi(countAssetsRoute, async (context) => {
+      const { projectId } = context.req.valid("param");
+      const count = await this.assetService.count({ projectId });
       return context.json(count, 200);
     });
-    this.api.openapi(listProjectsRoute, async (context) => {
+    this.api.openapi(readAssetRoute, async (context) => {
+      const { projectId, assetId } = context.req.valid("param");
+      const asset = await this.assetService.read({
+        projectId,
+        id: assetId
+      });
+      return context.json(asset, 200);
+    });
+  }
+};
+var listAssetsRoute = createRoute({
+  tags: ["Assets"],
+  description: "Lists all Assets of the given Project",
+  method: "get",
+  path: "/projects/{projectId}/assets",
+  operationId: "listAssets",
+  request: {
+    params: z13.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      })
+    }),
+    query: z13.object({
+      limit: z13.string().pipe(z13.coerce.number()).optional().openapi({
+        default: "15",
+        description: "The maximum number of items to return"
+      }),
+      offset: z13.string().pipe(z13.coerce.number()).optional().openapi({
+        default: "0",
+        description: "The number of items to skip before starting to collect the result set"
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: paginatedListOf(assetSchema)
+        }
+      },
+      description: "A list of Assets of the given Project"
+    }
+  }
+});
+var countAssetsRoute = createRoute({
+  tags: ["Assets"],
+  description: "Counts all Assets of the given Project",
+  method: "get",
+  path: "/projects/{projectId}/assets/count",
+  operationId: "countAssets",
+  request: {
+    params: z13.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z13.number()
+        }
+      },
+      description: "The number of Assets of the given Project"
+    }
+  }
+});
+var readAssetRoute = createRoute({
+  tags: ["Assets"],
+  description: "Retrieve an Asset by ID",
+  method: "get",
+  path: "/projects/{projectId}/assets/{assetId}",
+  operationId: "readAsset",
+  request: {
+    params: z13.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      }),
+      assetId: uuidSchema.openapi({
+        param: {
+          name: "assetId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: assetSchema
+        }
+      },
+      description: "The requested Asset"
+    },
+    404: {
+      description: "The requested Asset does not exist"
+    }
+  }
+});
+
+// src/api/v1/collection.ts
+import { createRoute as createRoute2, OpenAPIHono as OpenAPIHono2, z as z14 } from "@hono/zod-openapi";
+var CollectionApiV1 = class {
+  api;
+  collectionService;
+  constructor(collectionService) {
+    this.collectionService = collectionService;
+    this.api = new OpenAPIHono2();
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    this.api.openapi(listCollectionsRoute, async (context) => {
+      const { projectId } = context.req.valid("param");
       const { limit, offset } = context.req.valid("query");
-      const projects = await this.projectService.list({ limit, offset });
-      return context.json(projects, 200);
+      const collections = await this.collectionService.list({
+        projectId,
+        limit,
+        offset
+      });
+      return context.json(collections, 200);
     });
-    this.api.openapi(readProjectRoute, async (context) => {
-      const { id } = context.req.valid("param");
-      const project = await this.projectService.read({ id });
-      return context.json(project, 200);
+    this.api.openapi(countCollectionsRoute, async (context) => {
+      const { projectId } = context.req.valid("param");
+      const count = await this.collectionService.count({ projectId });
+      return context.json(count, 200);
+    });
+    this.api.openapi(readCollectionRoute, async (context) => {
+      const { projectId, collectionId } = context.req.valid("param");
+      const collection = await this.collectionService.read({
+        projectId,
+        id: collectionId
+      });
+      return context.json(collection, 200);
     });
   }
 };
-var countProjectsRoute = createRoute({
-  tags: ["Projects"],
-  description: "Counts all Projects you currently have access to",
+var listCollectionsRoute = createRoute2({
+  tags: ["Collections"],
+  description: "Lists all Collections of the given Project",
   method: "get",
-  path: "/count",
-  operationId: "countProjects",
+  path: "/projects/{projectId}/collections",
+  operationId: "listCollections",
+  request: {
+    params: z14.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      })
+    }),
+    query: z14.object({
+      limit: z14.string().pipe(z14.coerce.number()).optional().openapi({
+        default: "15",
+        description: "The maximum number of items to return"
+      }),
+      offset: z14.string().pipe(z14.coerce.number()).optional().openapi({
+        default: "0",
+        description: "The number of items to skip before starting to collect the result set"
+      })
+    })
+  },
   responses: {
     200: {
       content: {
         "application/json": {
-          schema: z13.number()
+          schema: paginatedListOf(collectionSchema)
         }
       },
-      description: "The number of Projects you have acces to"
+      description: "A list of Collections of the given Project"
+    }
+  }
+});
+var countCollectionsRoute = createRoute2({
+  tags: ["Collections"],
+  description: "Counts all Collections of the given Project",
+  method: "get",
+  path: "/projects/{projectId}/collections/count",
+  operationId: "countCollections",
+  request: {
+    params: z14.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z14.number()
+        }
+      },
+      description: "The number of Collections of the given Project"
     }
   }
 });
-var listProjectsRoute = createRoute({
+var readCollectionRoute = createRoute2({
+  tags: ["Collections"],
+  description: "Retrieve a Project by ID",
+  method: "get",
+  path: "/projects/{projectId}/collections/{collectionId}",
+  operationId: "readCollection",
+  request: {
+    params: z14.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      }),
+      collectionId: uuidSchema.openapi({
+        param: {
+          name: "collectionId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: collectionSchema
+        }
+      },
+      description: "The requested Collection"
+    },
+    404: {
+      description: "The requested Collection does not exist"
+    }
+  }
+});
+
+// src/api/v1/entry.ts
+import { createRoute as createRoute3, OpenAPIHono as OpenAPIHono3, z as z15 } from "@hono/zod-openapi";
+var EntryApiV1 = class {
+  api;
+  entryService;
+  constructor(entryService) {
+    this.entryService = entryService;
+    this.api = new OpenAPIHono3();
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    this.api.openapi(listEntriesRoute, async (context) => {
+      const { projectId, collectionId } = context.req.valid("param");
+      const { limit, offset } = context.req.valid("query");
+      const entries = await this.entryService.list({
+        projectId,
+        collectionId,
+        limit,
+        offset
+      });
+      return context.json(entries, 200);
+    });
+    this.api.openapi(countEntriesRoute, async (context) => {
+      const { projectId, collectionId } = context.req.valid("param");
+      const count = await this.entryService.count({ projectId, collectionId });
+      return context.json(count, 200);
+    });
+    this.api.openapi(readEntryRoute, async (context) => {
+      const { projectId, collectionId, entryId } = context.req.valid("param");
+      const entry = await this.entryService.read({
+        projectId,
+        collectionId,
+        id: entryId
+      });
+      return context.json(entry, 200);
+    });
+  }
+};
+var listEntriesRoute = createRoute3({
+  tags: ["Entries"],
+  description: "Lists all Entries of the given Project",
+  method: "get",
+  path: "/projects/{projectId}/collections/{collectionId}/entries",
+  operationId: "listEntries",
+  request: {
+    params: z15.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      }),
+      collectionId: uuidSchema.openapi({
+        param: {
+          name: "collectionId",
+          in: "path"
+        }
+      })
+    }),
+    query: z15.object({
+      limit: z15.string().pipe(z15.coerce.number()).optional().openapi({
+        default: "15",
+        description: "The maximum number of items to return"
+      }),
+      offset: z15.string().pipe(z15.coerce.number()).optional().openapi({
+        default: "0",
+        description: "The number of items to skip before starting to collect the result set"
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: paginatedListOf(entrySchema)
+        }
+      },
+      description: "A list of Entries of the given Project"
+    }
+  }
+});
+var countEntriesRoute = createRoute3({
+  tags: ["Entries"],
+  description: "Counts all Entries of the given Project",
+  method: "get",
+  path: "/projects/{projectId}/collections/{collectionId}/entries/count",
+  operationId: "countEntries",
+  request: {
+    params: z15.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      }),
+      collectionId: uuidSchema.openapi({
+        param: {
+          name: "collectionId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z15.number()
+        }
+      },
+      description: "The number of Entries of the given Project"
+    }
+  }
+});
+var readEntryRoute = createRoute3({
+  tags: ["Entries"],
+  description: "Retrieve a Project by ID",
+  method: "get",
+  path: "/projects/{projectId}/collections/{collectionId}/entries/{entryId}",
+  operationId: "readCollection",
+  request: {
+    params: z15.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      }),
+      collectionId: uuidSchema.openapi({
+        param: {
+          name: "collectionId",
+          in: "path"
+        }
+      }),
+      entryId: uuidSchema.openapi({
+        param: {
+          name: "entryId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: entrySchema
+        }
+      },
+      description: "The requested Collection"
+    },
+    404: {
+      description: "The requested Collection does not exist"
+    }
+  }
+});
+
+// src/api/v1/project.ts
+import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4, z as z16 } from "@hono/zod-openapi";
+var ProjectApiV1 = class {
+  api;
+  projectService;
+  constructor(projectService) {
+    this.projectService = projectService;
+    this.api = new OpenAPIHono4();
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    this.api.openapi(listProjectsRoute, async (context) => {
+      const { limit, offset } = context.req.valid("query");
+      const projects = await this.projectService.list({ limit, offset });
+      return context.json(projects, 200);
+    });
+    this.api.openapi(countProjectsRoute, async (context) => {
+      const count = await this.projectService.count();
+      return context.json(count, 200);
+    });
+    this.api.openapi(readProjectRoute, async (context) => {
+      const { projectId } = context.req.valid("param");
+      const project = await this.projectService.read({ id: projectId });
+      return context.json(project, 200);
+    });
+  }
+};
+var listProjectsRoute = createRoute4({
   tags: ["Projects"],
   description: "Lists all Projects you currently have access to",
   method: "get",
-  path: "/",
+  path: "/projects",
   operationId: "listProjects",
   request: {
-    query: listProjectsSchema
+    query: z16.object({
+      limit: z16.string().pipe(z16.coerce.number()).optional().openapi({
+        default: "15",
+        description: "The maximum number of items to return"
+      }),
+      offset: z16.string().pipe(z16.coerce.number()).optional().openapi({
+        default: "0",
+        description: "The number of items to skip before starting to collect the result set"
+      })
+    })
   },
   responses: {
     200: {
@@ -1019,17 +1447,34 @@ var listProjectsRoute = createRoute({
     }
   }
 });
-var readProjectRoute = createRoute({
+var countProjectsRoute = createRoute4({
+  tags: ["Projects"],
+  description: "Counts all Projects you currently have access to",
+  method: "get",
+  path: "/projects/count",
+  operationId: "countProjects",
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z16.number()
+        }
+      },
+      description: "The number of Projects you have acces to"
+    }
+  }
+});
+var readProjectRoute = createRoute4({
   tags: ["Projects"],
   description: "Retrieve a Project by ID",
   method: "get",
-  path: "/{id}",
+  path: "/projects/{projectId}",
   operationId: "readProject",
   request: {
-    params: z13.object({
-      id: uuidSchema.openapi({
+    params: z16.object({
+      projectId: uuidSchema.openapi({
         param: {
-          name: "id",
+          name: "projectId",
           in: "path"
         }
       })
@@ -1054,20 +1499,64 @@ var readProjectRoute = createRoute({
 var LocalApi = class {
   logService;
   projectService;
+  collectionService;
+  entryService;
+  assetService;
   api;
   server = null;
-  constructor(logService, projectService) {
+  constructor(logService, projectService, collectionService, entryService, assetService) {
     this.logService = logService;
     this.projectService = projectService;
-    this.api = new OpenAPIHono2();
+    this.collectionService = collectionService;
+    this.entryService = entryService;
+    this.assetService = assetService;
+    this.api = new OpenAPIHono5();
     this.api.use(
       cors({
         origin: ["http://localhost"]
       })
     );
-    this.registerRoutes();
-    this.api.doc("/openapi.json", {
+    this.api.use(new LoggerMiddleware(logService).handler);
+    this.registerRoutesV1();
+  }
+  /**
+   * Starts the local API on given port
+   */
+  start(port) {
+    this.server = serve(
+      {
+        fetch: this.api.fetch,
+        port
+      },
+      (info) => {
+        this.logService.info(
+          `Started local API on ${info.address}:${info.port} (${info.family})`
+        );
+      }
+    );
+  }
+  /**
+   * Stops the local API
+   */
+  stop() {
+    this.server?.close(() => {
+      this.logService.info("Stopped local API");
+    });
+  }
+  /**
+   * Returns true if the local API is running
+   */
+  isRunning() {
+    if (this.server?.listening) {
+      return true;
+    }
+    return false;
+  }
+  registerRoutesV1() {
+    const apiV1 = new OpenAPIHono5();
+    apiV1.doc("/openapi.json", {
       openapi: "3.0.0",
+      externalDocs: { url: "https://elek.io/docs" },
       info: {
         version: "0.1.0",
         title: "elek.io Project API",
@@ -1113,44 +1602,12 @@ var LocalApi = class {
         }
       ]
     });
-    this.api.get("/ui", swaggerUI({ url: "/openapi.json" }));
-  }
-  /**
-   * Starts the local API on given port
-   */
-  start(port) {
-    this.server = serve(
-      {
-        fetch: this.api.fetch,
-        port
-      },
-      (info) => {
-        this.logService.info(
-          `Started local API on ${info.address}:${info.port} (${info.family})`
-        );
-      }
-    );
-  }
-  /**
-   * Stops the local API
-   */
-  stop() {
-    this.server?.close(() => {
-      this.logService.info("Stopped local API");
-    });
-  }
-  /**
-   * Returns true if the local API is running
-   */
-  isRunning() {
-    if (this.server?.listening) {
-      return true;
-    }
-    return false;
-  }
-  registerRoutes() {
-    const projectsV1 = new ProjectsApiV1(this.projectService);
-    this.api.route("/v1/projects", projectsV1.api);
+    apiV1.get("/ui", swaggerUI({ url: "/v1/openapi.json" }));
+    apiV1.route("/", new ProjectApiV1(this.projectService).api);
+    apiV1.route("/", new CollectionApiV1(this.collectionService).api);
+    apiV1.route("/", new EntryApiV1(this.entryService).api);
+    apiV1.route("/", new AssetApiV1(this.assetService).api);
+    this.api.route("/v1", apiV1);
   }
 };
 
@@ -1869,15 +2326,13 @@ var EntryService = class extends AbstractCrudService {
   jsonFileService;
   gitService;
   collectionService;
-  assetService;
   // private sharedValueService: SharedValueService;
-  constructor(options, logService, jsonFileService, gitService, collectionService, assetService) {
+  constructor(options, logService, jsonFileService, gitService, collectionService) {
     super(serviceTypeSchema.Enum.Entry, options);
     this.logService = logService;
     this.jsonFileService = jsonFileService;
     this.gitService = gitService;
     this.collectionService = collectionService;
-    this.assetService = assetService;
   }
   /**
    * Creates a new Entry for given Collection
@@ -2114,74 +2569,6 @@ var EntryService = class extends AbstractCrudService {
       }
     });
   }
-  /**
-   * 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.objectType) {
-      case objectTypeSchema.Enum.asset:
-        return await this.assetService.read({
-          projectId: props.projectId,
-          id: props.valueContentReference.id
-        });
-      case objectTypeSchema.Enum.entry:
-        return await this.read({
-          projectId: props.projectId,
-          collectionId: props.collectionId,
-          id: props.valueContentReference.id
-        });
-      // case objectTypeSchema.Enum.sharedValue:
-      //   return this.resolveValueContentReferenceToSharedValue({
-      //     projectId: props.projectId,
-      //     valueContentReferenceToSharedValue: props.valueContentReference,
-      //   });
-      default:
-        throw new Error(
-          // @ts-ignore
-          `Tried to resolve unsupported Value reference "${props.valueContentReference.referenceObjectType}"`
-        );
-    }
-  }
-  async resolveValueContentReferences(props) {
-    let resolvedContent = {};
-    for (const language in props.valueReference.content) {
-      const referencesOfLanguage = props.valueReference.content[language];
-      if (!referencesOfLanguage) {
-        throw new Error(
-          `Trying to access content references by language "${language}" failed`
-        );
-      }
-      const resolvedReferencesOfLanguage = await Promise.all(
-        referencesOfLanguage.map(async (reference) => {
-          return await this.resolveValueContentReference({
-            projectId: props.projectId,
-            collectionId: props.collectionId,
-            valueContentReference: reference
-          });
-        })
-      );
-      resolvedContent = {
-        ...resolvedContent,
-        [language]: resolvedReferencesOfLanguage
-      };
-    }
-    return resolvedContent;
-  }
   /**
    * Creates an Entry from given EntryFile by resolving it's Values
    */
@@ -2191,24 +2578,7 @@ var EntryService = class extends AbstractCrudService {
     });
     return {
       ...entryFile,
-      history,
-      // @ts-ignore @todo fixme - I have no idea why this happens. The types seem to be compatible to me and they work
-      values: await Promise.all(
-        entryFile.values.map(async (value) => {
-          if (value.valueType === ValueTypeSchema.Enum.reference) {
-            const resolvedContentReferences = await this.resolveValueContentReferences({
-              projectId,
-              collectionId,
-              valueReference: value
-            });
-            return {
-              ...value,
-              content: resolvedContentReferences
-            };
-          }
-          return value;
-        })
-      )
+      history
     };
   }
 };
@@ -3744,8 +4114,7 @@ var ElekIoCore = class {
       this.logService,
       this.jsonFileService,
       this.gitService,
-      this.collectionService,
-      this.assetService
+      this.collectionService
     );
     this.projectService = new ProjectService(
       this.coreVersion,
@@ -3758,7 +4127,13 @@ var ElekIoCore = class {
       this.collectionService,
       this.entryService
     );
-    this.localApi = new LocalApi(this.logService, this.projectService);
+    this.localApi = new LocalApi(
+      this.logService,
+      this.projectService,
+      this.collectionService,
+      this.entryService,
+      this.assetService
+    );
     this.logService.info(`Initializing elek.io Core ${this.coreVersion}`, {
       options: this.options
     });
@@ -3916,9 +4291,6 @@ export {
   readGitTagSchema,
   readProjectSchema,
   referencedValueSchema,
-  resolvedReferencedValueSchema,
-  resolvedValueContentReferenceSchema,
-  resolvedValueSchema,
   saveAssetSchema,
   searchProjectSchema,
   serviceTypeSchema,