@elek-io/core 0.11.0 → 0.12.0

package/dist/node/index.node.js

@@ -8,7 +8,16 @@ var __export = (target, all) => {
 import Fs7 from "fs-extra";
 
 // package.json
-var version = "0.11.0";
+var version = "0.12.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 { cors } from "hono/cors";
+
+// src/api/v1/projects.ts
+import { createRoute, OpenAPIHono, z as z13 } from "@hono/zod-openapi";
 
 // src/schema/assetSchema.ts
 import z4 from "zod";
@@ -743,7 +752,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 +780,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,10 +889,24 @@ 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(),
-  offset: z11.number().optional()
+  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"
+  })
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -904,6 +926,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 +956,204 @@ var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
+// src/api/v1/projects.ts
+var ProjectsApiV1 = class {
+  api;
+  projectService;
+  constructor(projectService) {
+    this.projectService = projectService;
+    this.api = new OpenAPIHono();
+    this.registerRoutes();
+  }
+  registerRoutes() {
+    this.api.openapi(countProjectsRoute, async (context) => {
+      const count = await this.projectService.count();
+      return context.json(count, 200);
+    });
+    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(readProjectRoute, async (context) => {
+      const { id } = context.req.valid("param");
+      const project = await this.projectService.read({ id });
+      return context.json(project, 200);
+    });
+  }
+};
+var countProjectsRoute = createRoute({
+  tags: ["Projects"],
+  description: "Counts all Projects you currently have access to",
+  method: "get",
+  path: "/count",
+  operationId: "countProjects",
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: z13.number()
+        }
+      },
+      description: "The number of Projects you have acces to"
+    }
+  }
+});
+var listProjectsRoute = createRoute({
+  tags: ["Projects"],
+  description: "Lists all Projects you currently have access to",
+  method: "get",
+  path: "/",
+  operationId: "listProjects",
+  request: {
+    query: listProjectsSchema
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: paginatedListOf(projectSchema)
+        }
+      },
+      description: "A list of Projects you have access to"
+    }
+  }
+});
+var readProjectRoute = createRoute({
+  tags: ["Projects"],
+  description: "Retrieve a Project by ID",
+  method: "get",
+  path: "/{id}",
+  operationId: "readProject",
+  request: {
+    params: z13.object({
+      id: uuidSchema.openapi({
+        param: {
+          name: "id",
+          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;
+  api;
+  server = null;
+  constructor(logService, projectService) {
+    this.logService = logService;
+    this.projectService = projectService;
+    this.api = new OpenAPIHono2();
+    this.api.use(
+      cors({
+        origin: ["http://localhost"]
+      })
+    );
+    this.registerRoutes();
+    this.api.doc("/openapi.json", {
+      openapi: "3.0.0",
+      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" }
+        }
+      ]
+    });
+    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);
+  }
+};
+
 // src/error/GitError.ts
 var GitError = class extends Error {
   constructor(message) {
@@ -1027,8 +1257,8 @@ var pathTo = {
   asset: (projectId, id, extension) => {
     return Path.join(pathTo.lfs(projectId), `${id}.${extension}`);
   },
-  tmpAsset: (id, extension) => {
-    return Path.join(pathTo.tmp, `${id}.${extension}`);
+  tmpAsset: (id, commitHash, extension) => {
+    return Path.join(pathTo.tmp, `${id}.${commitHash}.${extension}`);
   }
 };
 function notEmpty(value) {
@@ -1107,6 +1337,7 @@ var AbstractCrudService = class {
           throw new RequiredParameterMissingError("projectId");
         }
         return this.getFileReferences(pathTo.lfs(projectId));
+      // LFS folder is correct, since we want the extension of the file itself, not the AssetFile (.json)
       case objectTypeSchema.Enum.project:
         return this.getFolderReferences(pathTo.projects);
       case objectTypeSchema.Enum.collection:
@@ -1279,11 +1510,11 @@ var AssetService = class extends AbstractCrudService {
         "binary"
       );
       await Fs2.writeFile(
-        pathTo.tmpAsset(assetFile.id, assetFile.extension),
+        pathTo.tmpAsset(assetFile.id, props.commitHash, assetFile.extension),
         assetBlob,
         "binary"
       );
-      return this.toAsset(props.projectId, assetFile, true);
+      return this.toAsset(props.projectId, assetFile, props.commitHash);
     }
   }
   /**
@@ -1407,8 +1638,8 @@ var AssetService = class extends AbstractCrudService {
    * @param projectId   The project's ID
    * @param assetFile   The AssetFile to convert
    */
-  async toAsset(projectId, assetFile, isFromHistory = false) {
-    const assetPath = isFromHistory === false ? pathTo.asset(projectId, assetFile.id, assetFile.extension) : pathTo.tmpAsset(assetFile.id, assetFile.extension);
+  async toAsset(projectId, assetFile, commitHash) {
+    const assetPath = commitHash ? pathTo.tmpAsset(assetFile.id, commitHash, assetFile.extension) : pathTo.asset(projectId, assetFile.id, assetFile.extension);
     const history = await this.gitService.log(pathTo.project(projectId), {
       filePath: pathTo.assetFile(projectId, assetFile.id)
     });
@@ -1914,6 +2145,11 @@ var EntryService = class extends AbstractCrudService {
           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
@@ -3437,7 +3673,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;
     }
   }
   /**
@@ -3471,6 +3707,7 @@ var ElekIoCore = class {
   projectService;
   collectionService;
   entryService;
+  localApi;
   constructor(props) {
     this.coreVersion = version;
     const parsedProps = constructorElekIoCoreSchema.parse(props);
@@ -3521,6 +3758,7 @@ var ElekIoCore = class {
       this.collectionService,
       this.entryService
     );
+    this.localApi = new LocalApi(this.logService, this.projectService);
     this.logService.info(`Initializing elek.io Core ${this.coreVersion}`, {
       options: this.options
     });
@@ -3576,6 +3814,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,
@@ -3655,6 +3900,7 @@ export {
   numberFieldDefinitionSchema,
   objectTypeSchema,
   outdatedProjectSchema,
+  paginatedListOf,
   projectBranchSchema,
   projectExportSchema,
   projectFileSchema,