@elek-io/core 0.11.1 → 0.13.0

package/dist/node/index.node.js

@@ -8,10 +8,44 @@ var __export = (target, all) => {
 import Fs7 from "fs-extra";
 
 // package.json
-var version = "0.11.1";
+var version = "0.13.0";
+
+// src/api/index.ts
+import { serve } from "@hono/node-server";
+import { swaggerUI } from "@hono/swagger-ui";
+import { OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
+import { cors } from "hono/cors";
+
+// 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";
@@ -262,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,
@@ -307,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";
@@ -338,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()
@@ -372,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({
@@ -386,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,
@@ -685,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)
 });
@@ -743,7 +763,7 @@ var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
 }).optional();
 
 // src/schema/projectSchema.ts
-import { z as z10 } from "zod";
+import { z as z10 } from "@hono/zod-openapi";
 var projectStatusSchema = z10.enum(["foo", "bar", "todo"]);
 var projectSettingsSchema = z10.object({
   language: z10.object({
@@ -771,17 +791,16 @@ var projectFileSchema = baseFileSchema.extend({
   settings: projectSettingsSchema
 });
 var projectSchema = projectFileSchema.extend({
-  remoteOriginUrl: z10.string().nullable(),
-  /**
-   * Commit history of this Project
-   */
-  history: z10.array(gitCommitSchema),
-  /**
-   * Full commit history of this Project
-   * including all Assets, Collections, Entries and other files
-   */
-  fullHistory: z10.array(gitCommitSchema)
-});
+  remoteOriginUrl: z10.string().nullable().openapi({
+    description: "URL of the remote Git repository"
+  }),
+  history: z10.array(gitCommitSchema).openapi({
+    description: "Commit history of this Project"
+  }),
+  fullHistory: z10.array(gitCommitSchema).openapi({
+    description: "Full commit history of this Project including all Assets, Collections, Entries and other files"
+  })
+}).openapi("Project");
 var outdatedProjectSchema = projectFileSchema.pick({
   id: true,
   name: true,
@@ -881,6 +900,14 @@ var serviceTypeSchema = z11.enum([
   "Entry",
   "Value"
 ]);
+function paginatedListOf(schema) {
+  return z11.object({
+    total: z11.number(),
+    limit: z11.number(),
+    offset: z11.number(),
+    list: z11.array(schema)
+  });
+}
 var listSchema = z11.object({
   projectId: uuidSchema,
   limit: z11.number().optional(),
@@ -904,6 +931,16 @@ var UserTypeSchema = z12.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
+  localApi: z12.object({
+    /**
+     * If set to true the local API is started whenever Core is initialized
+     */
+    isEnabled: z12.boolean(),
+    /**
+     * The port the local API uses
+     */
+    port: z12.number()
+  }),
   window: z12.object({
     width: z12.number(),
     height: z12.number(),
@@ -924,6 +961,656 @@ var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
+// src/api/v1/asset.ts
+var AssetApiV1 = class {
+  api;
+  assetService;
+  constructor(assetService) {
+    this.assetService = assetService;
+    this.api = new OpenAPIHono();
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    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(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 collections = await this.collectionService.list({
+        projectId,
+        limit,
+        offset
+      });
+      return context.json(collections, 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 listCollectionsRoute = createRoute2({
+  tags: ["Collections"],
+  description: "Lists all Collections of the given Project",
+  method: "get",
+  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: paginatedListOf(collectionSchema)
+        }
+      },
+      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 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: "/projects",
+  operationId: "listProjects",
+  request: {
+    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: {
+      content: {
+        "application/json": {
+          schema: paginatedListOf(projectSchema)
+        }
+      },
+      description: "A list of Projects you have access to"
+    }
+  }
+});
+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: "/projects/{projectId}",
+  operationId: "readProject",
+  request: {
+    params: z16.object({
+      projectId: uuidSchema.openapi({
+        param: {
+          name: "projectId",
+          in: "path"
+        }
+      })
+    })
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: projectSchema
+        }
+      },
+      description: "The requested Project"
+    },
+    404: {
+      description: "The requested Project does not exist or you have no right to access it"
+    }
+  }
+});
+
+// src/api/index.ts
+var LocalApi = class {
+  logService;
+  projectService;
+  collectionService;
+  entryService;
+  assetService;
+  api;
+  server = null;
+  constructor(logService, projectService, collectionService, entryService, assetService) {
+    this.logService = logService;
+    this.projectService = projectService;
+    this.collectionService = collectionService;
+    this.entryService = entryService;
+    this.assetService = assetService;
+    this.api = new OpenAPIHono5();
+    this.api.use(
+      cors({
+        origin: ["http://localhost"]
+      })
+    );
+    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",
+        description: "This API allows reading data from elek.io Projects"
+      },
+      servers: [
+        {
+          url: "http://localhost:{port}/v1/",
+          description: "Local development API",
+          variables: {
+            port: {
+              default: 31310,
+              description: "The port specified in elek.io Clients user configuration"
+            }
+          }
+        },
+        {
+          url: "https://api.elek.io/v1/",
+          description: "Public production API",
+          variables: {}
+        }
+      ],
+      tags: [
+        {
+          name: "Projects",
+          description: "Retrieve information about Projects",
+          externalDocs: { url: "https://elek.io/docs/projects" }
+        },
+        {
+          name: "Collections",
+          description: "Retrieve information about Collections",
+          externalDocs: { url: "https://elek.io/docs/collections" }
+        },
+        {
+          name: "Entries",
+          description: "Retrieve information about Entries",
+          externalDocs: { url: "https://elek.io/docs/entries" }
+        },
+        {
+          name: "Assets",
+          description: "Retrieve information about Assets",
+          externalDocs: { url: "https://elek.io/docs/assets" }
+        }
+      ]
+    });
+    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);
+  }
+};
+
 // src/error/GitError.ts
 var GitError = class extends Error {
   constructor(message) {
@@ -1639,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
@@ -1884,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
    */
@@ -1961,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
     };
   }
 };
@@ -3443,7 +4043,7 @@ var UserService = class {
       return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
     } catch (error) {
       this.logService.info("No User found");
-      return void 0;
+      return null;
     }
   }
   /**
@@ -3477,6 +4077,7 @@ var ElekIoCore = class {
   projectService;
   collectionService;
   entryService;
+  localApi;
   constructor(props) {
     this.coreVersion = version;
     const parsedProps = constructorElekIoCoreSchema.parse(props);
@@ -3513,8 +4114,7 @@ var ElekIoCore = class {
       this.logService,
       this.jsonFileService,
       this.gitService,
-      this.collectionService,
-      this.assetService
+      this.collectionService
     );
     this.projectService = new ProjectService(
       this.coreVersion,
@@ -3527,6 +4127,13 @@ var ElekIoCore = class {
       this.collectionService,
       this.entryService
     );
+    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
     });
@@ -3582,6 +4189,13 @@ var ElekIoCore = class {
   get entries() {
     return this.entryService;
   }
+  /**
+   * Allows starting and stopping a REST API
+   * to allow developers to read local Project data
+   */
+  get api() {
+    return this.localApi;
+  }
 };
 export {
   BooleanFieldDefinitionBaseSchema,
@@ -3661,6 +4275,7 @@ export {
   numberFieldDefinitionSchema,
   objectTypeSchema,
   outdatedProjectSchema,
+  paginatedListOf,
   projectBranchSchema,
   projectExportSchema,
   projectFileSchema,
@@ -3676,9 +4291,6 @@ export {
   readGitTagSchema,
   readProjectSchema,
   referencedValueSchema,
-  resolvedReferencedValueSchema,
-  resolvedValueContentReferenceSchema,
-  resolvedValueSchema,
   saveAssetSchema,
   searchProjectSchema,
   serviceTypeSchema,