@elek-io/core 0.10.0 → 0.11.1

package/dist/node/index.node.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 import Fs7 from "fs-extra";
 
 // package.json
-var version = "0.10.0";
+var version = "0.11.1";
 
 // src/schema/assetSchema.ts
 import z4 from "zod";
@@ -69,39 +69,6 @@ var supportedLanguageSchema = z.enum([
   // (Simplified) Chinese
 ]);
 var supportedIconSchema = z.enum(["home", "plus", "foobar"]);
-var supportedAssetMimeTypeSchema = z.enum([
-  "image/avif",
-  "image/gif",
-  "image/jpeg",
-  "image/png",
-  "image/svg+xml",
-  "image/webp",
-  "application/pdf",
-  "application/zip",
-  "video/mp4",
-  "video/webm",
-  "audio/webm",
-  "audio/flac"
-]);
-var supportedAssetExtensionSchema = z.enum([
-  "avif",
-  "gif",
-  "jpg",
-  "jpeg",
-  "png",
-  "svg",
-  "webp",
-  "pdf",
-  "zip",
-  "mp4",
-  "webm",
-  "flac",
-  "json"
-]);
-var supportedAssetTypeSchema = z.object({
-  extension: supportedAssetExtensionSchema,
-  mimeType: supportedAssetMimeTypeSchema
-});
 var objectTypeSchema = z.enum([
   "project",
   "asset",
@@ -151,48 +118,47 @@ var baseFileSchema = z2.object({
    */
   updated: z2.string().datetime().nullable()
 });
-var baseFileWithLanguageSchema = baseFileSchema.extend({
-  /**
-   * The language of the file
-   *
-   * The language is part of the files name and together with it's ID the only unique identifier.
-   * That's why the language cannot be changed after creating the file.
-   *
-   * @todo Maybe remove the above restriction by implementing logic to handle changing the files language inside all services
-   */
-  language: supportedLanguageSchema.readonly()
-});
 var fileReferenceSchema = z2.object({
   id: uuidSchema,
-  language: supportedLanguageSchema.optional(),
-  extension: supportedAssetExtensionSchema.optional()
+  extension: z2.string().optional()
 });
 
 // src/schema/gitSchema.ts
 import { z as z3 } from "zod";
-var gitRepositoryPathSchema = z3.string();
 var gitSignatureSchema = z3.object({
   name: z3.string(),
   email: z3.string()
 });
+var gitMessageSchema = z3.object({
+  method: z3.enum(["create", "update", "delete", "upgrade"]),
+  reference: z3.object({
+    objectType: objectTypeSchema,
+    /**
+     * ID of the objectType
+     */
+    id: uuidSchema,
+    /**
+     * Only present if the objectType is of "entry"
+     */
+    collectionId: uuidSchema.optional()
+  })
+});
+var gitTagSchema = z3.object({
+  id: uuidSchema,
+  message: z3.string(),
+  author: gitSignatureSchema,
+  datetime: z3.string().datetime()
+});
 var gitCommitSchema = z3.object({
   /**
    * SHA-1 hash of the commit
    */
   hash: z3.string(),
-  message: z3.string(),
+  message: gitMessageSchema,
   author: gitSignatureSchema,
   datetime: z3.string().datetime(),
-  tag: z3.string().nullable()
-});
-var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
-  GitCommitIconNative2["INIT"] = ":tada:";
-  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
-  GitCommitIconNative2["UPDATE"] = ":wrench:";
-  GitCommitIconNative2["DELETE"] = ":heavy_minus_sign:";
-  return GitCommitIconNative2;
-})(GitCommitIconNative || {});
-var gitCommitIconSchema = z3.nativeEnum(GitCommitIconNative);
+  tag: gitTagSchema.nullable()
+});
 var gitInitOptionsSchema = z3.object({
   /**
    * Use the specified name for the initial branch in the newly created repository. If not specified, fall back to the default name (currently master, but this is subject to change in the future; the name can be customized via the init.defaultBranch configuration variable).
@@ -211,7 +177,19 @@ var gitCloneOptionsSchema = z3.object({
   /**
    * Instead of pointing the newly created HEAD to the branch pointed to by the cloned repository’s HEAD, point to <name> branch instead. In a non-bare repository, this is the branch that will be checked out. --branch can also take tags and detaches the HEAD at that commit in the resulting repository.
    */
-  branch: z3.string()
+  branch: z3.string(),
+  /**
+   * Make a bare Git repository. That is, instead of creating <directory> and placing the administrative files in <directory>`/.git`, make the <directory> itself the $GIT_DIR.
+   * Used primarily to copy an existing local repository to a server, where you want to set up the repository as a central point to work with others.
+   *
+   * The destination path for the cloned repository should end with a .git by convention.
+   *
+   * @see https://git-scm.com/book/en/v2/Git-on-the-Server-Getting-Git-on-a-Server
+   */
+  bare: z3.boolean()
+});
+var gitMergeOptionsSchema = z3.object({
+  squash: z3.boolean()
 });
 var gitSwitchOptionsSchema = z3.object({
   /**
@@ -248,14 +226,28 @@ var gitLogOptionsSchema = z3.object({
    */
   filePath: z3.string().optional()
 });
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: z3.string(),
+  hash: z3.string().optional()
+});
+var readGitTagSchema = z3.object({
+  path: z3.string(),
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = z3.object({
+  path: z3.string()
+});
 
 // src/schema/assetSchema.ts
 var assetFileSchema = baseFileSchema.extend({
   objectType: z4.literal(objectTypeSchema.Enum.asset).readonly(),
   name: z4.string(),
   description: z4.string(),
-  extension: supportedAssetExtensionSchema.readonly(),
-  mimeType: supportedAssetMimeTypeSchema.readonly(),
+  extension: z4.string().readonly(),
+  mimeType: z4.string().readonly(),
   /**
    * Total size in bytes
    */
@@ -331,9 +323,6 @@ var ValueTypeSchema = z5.enum([
 var valueContentReferenceBase = z5.object({
   id: uuidSchema
 });
-var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
-  language: supportedLanguageSchema
-});
 var valueContentReferenceToAssetSchema = valueContentReferenceBase.extend({
   objectType: z5.literal(objectTypeSchema.Enum.asset)
 });
@@ -564,7 +553,6 @@ var ReferenceFieldDefinitionBaseSchema = FieldDefinitionBaseSchema.extend({
 });
 var assetFieldDefinitionSchema = ReferenceFieldDefinitionBaseSchema.extend({
   fieldType: z7.literal(FieldTypeSchema.Enum.asset),
-  allowedMimeTypes: z7.array(supportedAssetMimeTypeSchema).min(1),
   min: z7.number().nullable(),
   max: z7.number().nullable()
 });
@@ -754,39 +742,16 @@ var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.partial({
   file: true
 }).optional();
 
-// src/schema/gitTagSchema.ts
-import { z as z10 } from "zod";
-var gitTagSchema = z10.object({
-  id: uuidSchema,
-  message: z10.string(),
-  author: gitSignatureSchema,
-  datetime: z10.string().datetime()
-});
-var createGitTagSchema = gitTagSchema.pick({
-  message: true
-}).extend({
-  path: gitRepositoryPathSchema,
-  hash: gitCommitSchema.shape.hash.optional()
-});
-var readGitTagSchema = z10.object({
-  path: gitRepositoryPathSchema,
-  id: uuidSchema.readonly()
-});
-var deleteGitTagSchema = readGitTagSchema.extend({});
-var countGitTagsSchema = z10.object({
-  path: gitRepositoryPathSchema
-});
-
 // src/schema/projectSchema.ts
-import { z as z11 } from "zod";
-var projectStatusSchema = z11.enum(["foo", "bar", "todo"]);
-var projectSettingsSchema = z11.object({
-  language: z11.object({
+import { z as z10 } from "zod";
+var projectStatusSchema = z10.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = z10.object({
+  language: z10.object({
     default: supportedLanguageSchema,
-    supported: z11.array(supportedLanguageSchema)
+    supported: z10.array(supportedLanguageSchema)
   })
 });
-var projectFolderSchema = z11.enum([
+var projectFolderSchema = z10.enum([
   "assets",
   "collections",
   "shared-values",
@@ -795,25 +760,27 @@ var projectFolderSchema = z11.enum([
   // 'public',
   // 'theme',
 ]);
+var projectBranchSchema = z10.enum(["production", "work"]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: z11.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: z10.literal(objectTypeSchema.Enum.project).readonly(),
   coreVersion: versionSchema,
-  name: z11.string().trim().min(1, "shared.projectNameRequired"),
-  description: z11.string().trim().min(1, "shared.projectDescriptionRequired"),
+  name: z10.string().trim().min(1, "shared.projectNameRequired"),
+  description: z10.string().trim().min(1, "shared.projectDescriptionRequired"),
   version: versionSchema,
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
 var projectSchema = projectFileSchema.extend({
+  remoteOriginUrl: z10.string().nullable(),
   /**
    * Commit history of this Project
    */
-  history: z11.array(gitCommitSchema),
+  history: z10.array(gitCommitSchema),
   /**
    * Full commit history of this Project
    * including all Assets, Collections, Entries and other files
    */
-  fullHistory: z11.array(gitCommitSchema)
+  fullHistory: z10.array(gitCommitSchema)
 });
 var outdatedProjectSchema = projectFileSchema.pick({
   id: true,
@@ -821,8 +788,8 @@ var outdatedProjectSchema = projectFileSchema.pick({
   coreVersion: true
 });
 var projectExportSchema = projectSchema.extend({
-  assets: z11.array(assetExportSchema),
-  collections: z11.array(collectionExportSchema)
+  assets: z10.array(assetExportSchema),
+  collections: z10.array(collectionExportSchema)
 });
 var createProjectSchema = projectSchema.pick({
   name: true,
@@ -832,9 +799,9 @@ var createProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var readProjectSchema = z11.object({
+var readProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  commitHash: z11.string().optional().readonly()
+  commitHash: z10.string().optional().readonly()
 });
 var updateProjectSchema = projectSchema.pick({
   id: true,
@@ -846,15 +813,17 @@ var updateProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var upgradeProjectSchema = z11.object({
+var upgradeProjectSchema = z10.object({
   id: uuidSchema.readonly(),
   /**
    * Force the upgrade even if the Project is up-to-date
    */
-  force: z11.boolean().optional()
+  force: z10.boolean().optional()
+});
+var deleteProjectSchema = readProjectSchema.extend({
+  force: z10.boolean().optional()
 });
-var deleteProjectSchema = readProjectSchema.extend({});
-var projectUpgradeSchema = z11.object({
+var projectUpgradeSchema = z10.object({
   /**
    * The Core version the Project will be upgraded to
    */
@@ -862,45 +831,45 @@ var projectUpgradeSchema = z11.object({
   /**
    * Function that will be executed in the process of upgrading a Project
    */
-  run: z11.function().args(projectFileSchema).returns(z11.promise(z11.void()))
+  run: z10.function().args(projectFileSchema).returns(z10.promise(z10.void()))
 });
-var cloneProjectSchema = z11.object({
-  url: z11.string()
+var cloneProjectSchema = z10.object({
+  url: z10.string()
 });
-var listBranchesProjectSchema = z11.object({
+var listBranchesProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var currentBranchProjectSchema = z11.object({
+var currentBranchProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var switchBranchProjectSchema = z11.object({
+var switchBranchProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  branch: z11.string(),
+  branch: z10.string(),
   options: gitSwitchOptionsSchema.optional()
 });
-var getRemoteOriginUrlProjectSchema = z11.object({
+var getRemoteOriginUrlProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var setRemoteOriginUrlProjectSchema = z11.object({
+var setRemoteOriginUrlProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  url: z11.string()
+  url: z10.string()
 });
-var getChangesProjectSchema = z11.object({
+var getChangesProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var synchronizeProjectSchema = z11.object({
+var synchronizeProjectSchema = z10.object({
   id: uuidSchema.readonly()
 });
-var searchProjectSchema = z11.object({
+var searchProjectSchema = z10.object({
   id: uuidSchema.readonly(),
-  query: z11.string(),
+  query: z10.string(),
   language: supportedLanguageSchema,
-  type: z11.array(objectTypeSchema).optional()
+  type: z10.array(objectTypeSchema).optional()
 });
 
 // src/schema/serviceSchema.ts
-import { z as z12 } from "zod";
-var serviceTypeSchema = z12.enum([
+import { z as z11 } from "zod";
+var serviceTypeSchema = z11.enum([
   "Git",
   "GitTag",
   "User",
@@ -912,10 +881,10 @@ var serviceTypeSchema = z12.enum([
   "Entry",
   "Value"
 ]);
-var listSchema = z12.object({
+var listSchema = z11.object({
   projectId: uuidSchema,
-  limit: z12.number().optional(),
-  offset: z12.number().optional()
+  limit: z11.number().optional(),
+  offset: z11.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -925,33 +894,33 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z12.object({
-  path: gitRepositoryPathSchema
+var listGitTagsSchema = z11.object({
+  path: z11.string()
 });
 
 // src/schema/userSchema.ts
-import z13 from "zod";
-var UserTypeSchema = z13.enum(["local", "cloud"]);
+import z12 from "zod";
+var UserTypeSchema = z12.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
-  window: z13.object({
-    width: z13.number(),
-    height: z13.number(),
-    position: z13.object({
-      x: z13.number(),
-      y: z13.number()
+  window: z12.object({
+    width: z12.number(),
+    height: z12.number(),
+    position: z12.object({
+      x: z12.number(),
+      y: z12.number()
     })
   }).nullable()
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z13.literal(UserTypeSchema.Enum.local)
+  userType: z12.literal(UserTypeSchema.Enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z13.literal(UserTypeSchema.Enum.cloud),
+  userType: z12.literal(UserTypeSchema.Enum.cloud),
   id: uuidSchema
 });
-var userFileSchema = z13.union([localUserSchema, cloudUserSchema]);
+var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
@@ -990,17 +959,14 @@ var RequiredParameterMissingError = class extends Error {
 // src/util/node.ts
 var node_exports = {};
 __export(node_exports, {
-  assignDefaultIfMissing: () => assignDefaultIfMissing,
   files: () => files,
   folders: () => folders,
   isNoError: () => isNoError,
   notEmpty: () => notEmpty,
   pathTo: () => pathTo,
   returnResolved: () => returnResolved,
-  spawnChildProcess: () => spawnChildProcess,
   workingDirectory: () => workingDirectory
 });
-import { spawn } from "child_process";
 import Fs from "fs-extra";
 import Os from "os";
 import Path from "path";
@@ -1061,13 +1027,10 @@ 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 assignDefaultIfMissing(value, defaultsTo) {
-  return Object.assign(defaultsTo, value);
-}
 function notEmpty(value) {
   if (value === null || value === void 0) {
     return false;
@@ -1100,27 +1063,6 @@ async function returnResolved(promises) {
   const checked = await Promise.all(toCheck);
   return checked.filter(isNoError);
 }
-function spawnChildProcess(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const childProcess = spawn(command, args, options);
-    let log = "";
-    childProcess.stdout.on("data", (data) => {
-      log += data;
-    });
-    childProcess.stderr.on("data", (data) => {
-      log += data;
-    });
-    childProcess.on("error", (error) => {
-      throw error;
-    });
-    childProcess.on("exit", (code) => {
-      if (code === 0) {
-        return resolve(log);
-      }
-      return reject(log);
-    });
-  });
-}
 async function folders(path) {
   const dirent = await Fs.readdir(path, { withFileTypes: true });
   return dirent.filter((dirent2) => {
@@ -1144,21 +1086,12 @@ async function files(path, extension) {
 var AbstractCrudService = class {
   type;
   options;
-  /**
-   * Dynamically generated git messages for operations
-   */
-  gitMessage;
   /**
    * Do not instantiate directly as this is an abstract class
    */
   constructor(type, options) {
     this.type = type;
     this.options = options;
-    this.gitMessage = {
-      create: `${gitCommitIconSchema.enum.CREATE} Created ${this.type}`,
-      update: `${gitCommitIconSchema.enum.UPDATE} Updated ${this.type}`,
-      delete: `${gitCommitIconSchema.enum.DELETE} Deleted ${this.type}`
-    };
   }
   /**
    * Returns a list of all file references of given project and type
@@ -1174,6 +1107,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:
@@ -1218,8 +1152,7 @@ var AbstractCrudService = class {
    * Searches for all files inside given folder,
    * parses their names and returns them as FileReference
    *
-   * Ignores files not matching the [id].[language].[extension]
-   * or [id].[extension] format for their names
+   * Ignores files if the extension is not supported.
    */
   async getFileReferences(path) {
     const possibleFiles = await files(path);
@@ -1227,9 +1160,8 @@ var AbstractCrudService = class {
       possibleFiles.map(async (possibleFile) => {
         const fileNameArray = possibleFile.name.split(".");
         const fileReference = {
-          id: fileNameArray[0] || "",
-          language: fileNameArray.length === 3 ? fileNameArray[1] : void 0,
-          extension: fileNameArray.length === 2 ? fileNameArray[1] : fileNameArray[2]
+          id: fileNameArray[0],
+          extension: fileNameArray[1]
         };
         try {
           return fileReferenceSchema.parse(fileReference);
@@ -1243,9 +1175,8 @@ var AbstractCrudService = class {
 };
 
 // src/service/AssetService.ts
-import { fileTypeFromFile } from "file-type";
 import Fs2 from "fs-extra";
-import isSvg from "is-svg";
+import mime from "mime";
 
 // src/util/shared.ts
 import slugify from "@sindresorhus/slugify";
@@ -1286,8 +1217,8 @@ var AssetService = class extends AbstractCrudService {
     createAssetSchema.parse(props);
     const id = uuid();
     const projectPath = pathTo.project(props.projectId);
-    const fileType = await this.getSupportedFileTypeOrThrow(props.filePath);
-    const size = await this.getAssetSize(props.filePath);
+    const fileType = this.getFileType(props.filePath);
+    const size = await this.getFileSize(props.filePath);
     const assetPath = pathTo.asset(props.projectId, id, fileType.extension);
     const assetFilePath = pathTo.assetFile(props.projectId, id);
     const assetFile = {
@@ -1313,7 +1244,10 @@ var AssetService = class extends AbstractCrudService {
       throw error;
     }
     await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: { objectType: "asset", id }
+    });
     return this.toAsset(props.projectId, assetFile);
   }
   /**
@@ -1346,11 +1280,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);
     }
   }
   /**
@@ -1378,10 +1312,8 @@ var AssetService = class extends AbstractCrudService {
       updated: datetime()
     };
     if (props.newFilePath) {
-      const fileType = await this.getSupportedFileTypeOrThrow(
-        props.newFilePath
-      );
-      const size = await this.getAssetSize(props.newFilePath);
+      const fileType = this.getFileType(props.newFilePath);
+      const size = await this.getFileSize(props.newFilePath);
       const prevAssetPath = pathTo.asset(
         props.projectId,
         props.id,
@@ -1405,7 +1337,10 @@ var AssetService = class extends AbstractCrudService {
       assetFileSchema
     );
     await this.gitService.add(projectPath, [assetFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "asset", id: assetFile.id }
+    });
     return this.toAsset(props.projectId, assetFile);
   }
   /**
@@ -1419,7 +1354,10 @@ var AssetService = class extends AbstractCrudService {
     await Fs2.remove(assetPath);
     await Fs2.remove(assetFilePath);
     await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: { objectType: "asset", id: props.id }
+    });
   }
   async list(props) {
     listAssetsSchema.parse(props);
@@ -1457,11 +1395,11 @@ var AssetService = class extends AbstractCrudService {
     return assetSchema.safeParse(obj).success;
   }
   /**
-   * Returns the size of an Asset in bytes
+   * Returns the size of an file in bytes
    *
-   * @param path Path of the Asset to get the size from
+   * @param path Path of the file to get the size from
    */
-  async getAssetSize(path) {
+  async getFileSize(path) {
     return (await Fs2.stat(path)).size;
   }
   /**
@@ -1470,8 +1408,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)
     });
@@ -1488,23 +1426,21 @@ var AssetService = class extends AbstractCrudService {
    *
    * @param filePath Path to the file to check
    */
-  async getSupportedFileTypeOrThrow(filePath) {
-    const fileSize = (await Fs2.stat(filePath)).size;
-    if (fileSize / 1e3 <= 500) {
-      const fileBuffer = await Fs2.readFile(filePath);
-      if (isSvg(fileBuffer.toString()) === true) {
-        return {
-          extension: supportedAssetExtensionSchema.Enum.svg,
-          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
-        };
-      }
+  getFileType(filePath) {
+    const mimeType = mime.getType(filePath);
+    if (mimeType === null) {
+      throw new Error(`Unsupported MIME type of file "${filePath}"`);
     }
-    const fileType = await fileTypeFromFile(filePath);
-    const result = supportedAssetTypeSchema.parse({
-      extension: fileType?.ext,
-      mimeType: fileType?.mime
-    });
-    return result;
+    const extension = mime.getExtension(mimeType);
+    if (extension === null) {
+      throw new Error(
+        `Unsupported extension for MIME type "${mimeType}" of file "${filePath}"`
+      );
+    }
+    return {
+      extension,
+      mimeType
+    };
   }
   /**
    * Migrates an potentially outdated Asset file to the current schema
@@ -1551,7 +1487,10 @@ var CollectionService = class extends AbstractCrudService {
       collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: { objectType: "collection", id }
+    });
     return this.toCollection(props.projectId, collectionFile);
   }
   /**
@@ -1606,7 +1545,10 @@ var CollectionService = class extends AbstractCrudService {
       collectionFileSchema
     );
     await this.gitService.add(projectPath, [collectionFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "collection", id: collectionFile.id }
+    });
     return this.toCollection(props.projectId, collectionFile);
   }
   /**
@@ -1620,7 +1562,10 @@ var CollectionService = class extends AbstractCrudService {
     const collectionPath = pathTo.collection(props.projectId, props.id);
     await Fs3.remove(collectionPath);
     await this.gitService.add(projectPath, [collectionPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: { objectType: "collection", id: props.id }
+    });
   }
   async list(props) {
     listCollectionsSchema.parse(props);
@@ -1743,7 +1688,14 @@ var EntryService = class extends AbstractCrudService {
       entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
+    await this.gitService.commit(projectPath, {
+      method: "create",
+      reference: {
+        objectType: "entry",
+        id: entryFile.id,
+        collectionId: props.collectionId
+      }
+    });
     return entry;
   }
   /**
@@ -1813,7 +1765,14 @@ var EntryService = class extends AbstractCrudService {
       entryFileSchema
     );
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: {
+        objectType: "entry",
+        id: entryFile.id,
+        collectionId: props.collectionId
+      }
+    });
     return entry;
   }
   /**
@@ -1829,7 +1788,14 @@ var EntryService = class extends AbstractCrudService {
     );
     await Fs4.remove(entryFilePath);
     await this.gitService.add(projectPath, [entryFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+    await this.gitService.commit(projectPath, {
+      method: "delete",
+      reference: {
+        objectType: "entry",
+        id: props.id,
+        collectionId: props.collectionId
+      }
+    });
   }
   async list(props) {
     listEntriesSchema.parse(props);
@@ -1949,6 +1915,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
@@ -2203,6 +2174,9 @@ var GitService = class {
    */
   async clone(url, path, options) {
     let args = ["clone", "--progress"];
+    if (options?.bare) {
+      args = [...args, "--bare"];
+    }
     if (options?.branch) {
       args = [...args, "--branch", options.branch];
     }
@@ -2303,6 +2277,21 @@ var GitService = class {
         args = [...args, branch];
       }
       await this.git(path, args);
+    },
+    /**
+     * Delete a branch
+     *
+     * @see https://git-scm.com/docs/git-branch#Documentation/git-branch.txt---delete
+     *
+     * @param path Path to the repository
+     * @param branch Name of the branch to delete
+     */
+    delete: async (path, branch, force) => {
+      let args = ["branch", "--delete"];
+      if (force === true) {
+        args = [...args, "--force"];
+      }
+      await this.git(path, [...args, branch]);
     }
   };
   remotes = {
@@ -2374,6 +2363,19 @@ var GitService = class {
       await this.git(path, args);
     }
   };
+  /**
+   * Join two development histories together
+   *
+   * @see https://git-scm.com/docs/git-merge
+   */
+  async merge(path, branch, options) {
+    let args = ["merge"];
+    if (options?.squash === true) {
+      args = [...args, "--squash"];
+    }
+    args = [...args, branch];
+    await this.git(path, args);
+  }
   /**
    * Reset current HEAD to the specified state
    *
@@ -2455,16 +2457,17 @@ var GitService = class {
    * @see https://git-scm.com/docs/git-commit
    *
    * @param path    Path to the repository
-   * @param message A message that describes the changes
+   * @param message An object describing the changes
    */
   async commit(path, message) {
+    gitMessageSchema.parse(message);
     const user = await this.userService.get();
     if (!user) {
       throw new NoCurrentUserError();
     }
     const args = [
       "commit",
-      `--message=${message}`,
+      `--message=${JSON.stringify(message)}`,
       `--author=${user.name} <${user.email}>`
     ];
     await this.git(path, args);
@@ -2499,19 +2502,23 @@ var GitService = class {
     const noEmptyLinesArr = result.stdout.split("\n").filter((line) => {
       return line.trim() !== "";
     });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        hash: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        datetime: datetime(lineArray[4]),
-        tag: this.refNameToTagName(lineArray[5] || "")
-      };
-    });
+    const lineObjArr = await Promise.all(
+      noEmptyLinesArr.map(async (line) => {
+        const lineArray = line.split("|");
+        const tagId = this.refNameToTagName(lineArray[5] || "");
+        const tag = tagId ? await this.tags.read({ path, id: tagId }) : null;
+        return {
+          hash: lineArray[0],
+          message: JSON.parse(lineArray[1] || ""),
+          author: {
+            name: lineArray[2],
+            email: lineArray[3]
+          },
+          datetime: datetime(lineArray[4]),
+          tag
+        };
+      })
+    );
     return lineObjArr.filter(this.isGitCommit.bind(this));
   }
   /**
@@ -2774,7 +2781,13 @@ var LogService = class {
         new transports.Console({
           handleExceptions: true,
           handleRejections: true,
-          format: format.cli()
+          format: format.combine(
+            format.colorize(),
+            format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+            format.printf((info) => {
+              return `${info.level} [${info["timestamp"]}]: ${info.message}`;
+            })
+          )
         })
       ]
     });
@@ -2785,16 +2798,16 @@ var LogService = class {
     });
   }
   debug(message, ...meta) {
-    return this.logger.debug(message, ...meta);
+    this.logger.debug(message, ...meta);
   }
   info(message, ...meta) {
-    return this.logger.info(message, ...meta);
+    this.logger.info(message, ...meta);
   }
   warn(message, ...meta) {
-    return this.logger.warn(message, ...meta);
+    this.logger.warn(message, ...meta);
   }
   error(message, ...meta) {
-    return this.logger.error(message, ...meta);
+    this.logger.error(message, ...meta);
   }
   read(options) {
     return this.logger.query(options);
@@ -2806,6 +2819,28 @@ import Fs6 from "fs-extra";
 import Os2 from "os";
 import Path4 from "path";
 import Semver from "semver";
+
+// src/error/RemoteOriginMissingError.ts
+var RemoteOriginMissingError = class extends Error {
+  constructor(projectId) {
+    super(
+      `Tried to delete Project "${projectId}" but it does not have a remote origin. Deleting a Project without a remote origin could lead to data loss. Use the "force" option to delete it anyway.`
+    );
+    this.name = "RemoteOriginMissingError";
+  }
+};
+
+// src/error/SynchronizeLocalChangesError.ts
+var SynchronizeLocalChangesError = class extends Error {
+  constructor(projectId) {
+    super(
+      `Tried to delete Project "${projectId}" but it has local changes that are not yet pushed to the remote origin. Deleting a Project with local changes could lead to data loss. Use the "force" option to delete it anyway.`
+    );
+    this.name = "SynchronizeLocalChangesError";
+  }
+};
+
+// src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
   coreVersion;
   logService;
@@ -2859,23 +2894,30 @@ var ProjectService = class extends AbstractCrudService {
     try {
       await this.createFolderStructure(projectPath);
       await this.createGitignore(projectPath);
-      await this.gitService.init(projectPath, { initialBranch: "main" });
+      await this.gitService.init(projectPath, {
+        initialBranch: projectBranchSchema.Enum.production
+      });
       await this.jsonFileService.create(
         projectFile,
         pathTo.projectFile(id),
         projectFileSchema
       );
       await this.gitService.add(projectPath, ["."]);
-      await this.gitService.commit(
+      await this.gitService.commit(projectPath, {
+        method: "create",
+        reference: { objectType: "project", id }
+      });
+      await this.gitService.branches.switch(
         projectPath,
-        `${gitCommitIconSchema.enum.INIT} Created this new elek.io project`
+        projectBranchSchema.Enum.work,
+        {
+          isNew: true
+        }
       );
-      await this.gitService.branches.switch(projectPath, "stage", {
-        isNew: true
-      });
     } catch (error) {
       await this.delete({
-        id
+        id,
+        force: true
       });
       throw error;
     }
@@ -2953,7 +2995,10 @@ var ProjectService = class extends AbstractCrudService {
     };
     await this.jsonFileService.update(projectFile, filePath, projectFileSchema);
     await this.gitService.add(projectPath, [filePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
+    await this.gitService.commit(projectPath, {
+      method: "update",
+      reference: { objectType: "project", id: projectFile.id }
+    });
     return await this.toProject(projectFile);
   }
   /**
@@ -2965,15 +3010,22 @@ var ProjectService = class extends AbstractCrudService {
     upgradeProjectSchema.parse(props);
     const projectPath = pathTo.project(props.id);
     const projectFilePath = pathTo.projectFile(props.id);
-    const prevProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
-    if (Semver.gt(prevProjectFile.coreVersion, this.coreVersion)) {
+    const currentBranch = await this.gitService.branches.current(projectPath);
+    if (currentBranch !== projectBranchSchema.Enum.work) {
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
+      );
+    }
+    const currentProjectFile = outdatedProjectSchema.passthrough().parse(await this.jsonFileService.unsafeRead(projectFilePath));
+    if (Semver.gt(currentProjectFile.coreVersion, this.coreVersion)) {
       throw new ProjectUpgradeError(
-        `The Projects Core version "${prevProjectFile.coreVersion}" is higher than the current Core version "${this.coreVersion}".`
+        `The Projects Core version "${currentProjectFile.coreVersion}" is higher than the current Core version "${this.coreVersion}".`
       );
     }
-    if (Semver.eq(prevProjectFile.coreVersion, this.coreVersion) && props.force !== true) {
+    if (Semver.eq(currentProjectFile.coreVersion, this.coreVersion) && props.force !== true) {
       throw new ProjectUpgradeError(
-        `The Projects Core version "${prevProjectFile.coreVersion}" is already up to date.`
+        `The Projects Core version "${currentProjectFile.coreVersion}" is already up to date.`
       );
     }
     const assetReferences = await this.listReferences("asset", props.id);
@@ -2982,11 +3034,11 @@ var ProjectService = class extends AbstractCrudService {
       props.id
     );
     this.logService.info(
-      `Attempting to upgrade Project "${props.id}" from Core version ${prevProjectFile.coreVersion} to ${this.coreVersion}`
+      `Attempting to upgrade Project "${props.id}" from Core version ${currentProjectFile.coreVersion} to ${this.coreVersion}`
     );
-    const failsafeTag = await this.gitService.tags.create({
-      path: projectPath,
-      message: `Attempting to upgrade Project from Core version ${prevProjectFile.coreVersion} to ${this.coreVersion}`
+    const upgradeBranchName = `upgrade/core-${currentProjectFile.coreVersion}-to-${this.coreVersion}`;
+    await this.gitService.branches.switch(projectPath, upgradeBranchName, {
+      isNew: true
     });
     try {
       await Promise.all(
@@ -3018,22 +3070,45 @@ var ProjectService = class extends AbstractCrudService {
           );
         })
       );
-      const migratedProjectFile = this.migrate(prevProjectFile);
+      const migratedProjectFile = this.migrate(currentProjectFile);
       await this.update(migratedProjectFile);
-      this.logService.info(`Upgraded project "${projectFilePath}"`, {
-        previous: prevProjectFile,
-        migrated: migratedProjectFile
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
+      );
+      await this.gitService.merge(projectPath, upgradeBranchName, {
+        squash: true
       });
-      await this.gitService.tags.create({
-        path: projectPath,
-        message: `Upgraded Project to Core version "${this.coreVersion}"`
+      await this.gitService.commit(projectPath, {
+        method: "upgrade",
+        reference: { objectType: "project", id: migratedProjectFile.id }
       });
-      await this.gitService.tags.delete({
+      await this.gitService.tags.create({
         path: projectPath,
-        id: failsafeTag.id
+        message: `Upgraded Project to Core version ${migratedProjectFile.coreVersion}`
       });
+      await this.gitService.branches.delete(
+        projectPath,
+        upgradeBranchName,
+        true
+      );
+      this.logService.info(
+        `Upgraded Project "${projectFilePath}" to Core version "${this.coreVersion}"`,
+        {
+          previous: currentProjectFile,
+          migrated: migratedProjectFile
+        }
+      );
     } catch (error) {
-      await this.gitService.reset(projectPath, "hard", failsafeTag.id);
+      await this.gitService.branches.switch(
+        projectPath,
+        projectBranchSchema.Enum.work
+      );
+      await this.gitService.branches.delete(
+        projectPath,
+        upgradeBranchName,
+        true
+      );
       throw error;
     }
   }
@@ -3062,38 +3137,37 @@ var ProjectService = class extends AbstractCrudService {
       );
     }
   };
-  remotes = {
-    getOriginUrl: async (props) => {
-      getRemoteOriginUrlProjectSchema.parse(props);
-      const projectPath = pathTo.project(props.id);
-      const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
-      if (!hasOrigin) {
-        return null;
-      } else {
-        return await this.gitService.remotes.getOriginUrl(projectPath);
-      }
-    },
-    setOriginUrl: async (props) => {
-      setRemoteOriginUrlProjectSchema.parse(props);
-      const projectPath = pathTo.project(props.id);
-      const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
-      if (!hasOrigin) {
-        await this.gitService.remotes.addOrigin(projectPath, props.url);
-      } else {
-        await this.gitService.remotes.setOriginUrl(projectPath, props.url);
-      }
+  /**
+   * Updates the remote origin URL of given Project
+   */
+  async setRemoteOriginUrl(props) {
+    setRemoteOriginUrlProjectSchema.parse(props);
+    const projectPath = pathTo.project(props.id);
+    const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+    if (!hasOrigin) {
+      await this.gitService.remotes.addOrigin(projectPath, props.url);
+    } else {
+      await this.gitService.remotes.setOriginUrl(projectPath, props.url);
     }
-  };
+  }
   /**
    * Returns the differences of the given Projects current branch
    * between the local and remote `origin` (commits ahead & behind)
    *
+   * Throws an error if the Project does not have a remote origin.
+   *
    * - `behind` contains a list of commits on the current branch that are available on the remote `origin` but not yet locally
    * - `ahead` contains a list of commits on the current branch that are available locally but not yet on the remote `origin`
    */
   async getChanges(props) {
     getChangesProjectSchema.parse(props);
     const projectPath = pathTo.project(props.id);
+    const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(
+      projectPath
+    );
+    if (hasRemoteOrigin === false) {
+      throw new Error(`Project "${props.id}" does not have a remote origin`);
+    }
     const currentBranch = await this.gitService.branches.current(projectPath);
     await this.gitService.fetch(projectPath);
     const behind = await this.gitService.log(projectPath, {
@@ -3121,11 +3195,23 @@ var ProjectService = class extends AbstractCrudService {
    * Deletes given Project
    *
    * Deletes the whole Project folder including the history, not only the config file.
-   * Use with caution, since a Project that is only available locally could be lost forever.
-   * Or changes that are not pushed to a remote yet, will be lost too.
+   * Throws in case a Project is only available locally and could be lost forever,
+   * or changes are not pushed to a remote yet.
    */
   async delete(props) {
     deleteProjectSchema.parse(props);
+    const hasRemoteOrigin = await this.gitService.remotes.hasOrigin(
+      pathTo.project(props.id)
+    );
+    if (hasRemoteOrigin === false && props.force !== true) {
+      throw new RemoteOriginMissingError(props.id);
+    }
+    if (hasRemoteOrigin === true && props.force !== true) {
+      const changes = await this.getChanges({ id: props.id });
+      if (changes.ahead.length > 0) {
+        throw new SynchronizeLocalChangesError(props.id);
+      }
+    }
     await Fs6.remove(pathTo.project(props.id));
   }
   /**
@@ -3220,6 +3306,12 @@ var ProjectService = class extends AbstractCrudService {
    * Creates a Project from given ProjectFile
    */
   async toProject(projectFile) {
+    const projectPath = pathTo.project(projectFile.id);
+    let remoteOriginUrl = null;
+    const hasOrigin = await this.gitService.remotes.hasOrigin(projectPath);
+    if (hasOrigin) {
+      remoteOriginUrl = await this.gitService.remotes.getOriginUrl(projectPath);
+    }
     const fullHistory = await this.gitService.log(
       pathTo.project(projectFile.id)
     );
@@ -3228,6 +3320,7 @@ var ProjectService = class extends AbstractCrudService {
     });
     return {
       ...projectFile,
+      remoteOriginUrl,
       history,
       fullHistory
     };
@@ -3505,7 +3598,6 @@ export {
   assetFileSchema,
   assetSchema,
   baseFileSchema,
-  baseFileWithLanguageSchema,
   baseUserSchema,
   cloneProjectSchema,
   cloudUserSchema,
@@ -3549,11 +3641,11 @@ export {
   getRemoteOriginUrlProjectSchema,
   getValueContentSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
-  gitCommitIconSchema,
   gitCommitSchema,
   gitInitOptionsSchema,
   gitLogOptionsSchema,
-  gitRepositoryPathSchema,
+  gitMergeOptionsSchema,
+  gitMessageSchema,
   gitSignatureSchema,
   gitSwitchOptionsSchema,
   gitTagSchema,
@@ -3569,6 +3661,7 @@ export {
   numberFieldDefinitionSchema,
   objectTypeSchema,
   outdatedProjectSchema,
+  projectBranchSchema,
   projectExportSchema,
   projectFileSchema,
   projectFolderSchema,
@@ -3593,9 +3686,6 @@ export {
   setUserSchema,
   slug,
   stringFieldDefinitionSchema,
-  supportedAssetExtensionSchema,
-  supportedAssetMimeTypeSchema,
-  supportedAssetTypeSchema,
   supportedIconSchema,
   supportedLanguageSchema,
   switchBranchProjectSchema,
@@ -3624,7 +3714,6 @@ export {
   valueContentReferenceToAssetSchema,
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema,
-  valueContentReferenceWithLanguageBase,
   valueSchema,
   versionSchema
 };