@elek-io/core 0.4.1 → 0.5.0

package/dist/{index.cjs → node/index.node.cjs}

@@ -27,9 +27,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// src/index.node.ts
+var index_node_exports = {};
+__export(index_node_exports, {
   BooleanValueDefinitionBaseSchema: () => BooleanValueDefinitionBaseSchema,
   NumberValueDefinitionBaseSchema: () => NumberValueDefinitionBaseSchema,
   ReferenceValueDefinitionBaseSchema: () => ReferenceValueDefinitionBaseSchema,
@@ -62,6 +62,7 @@ __export(src_exports, {
   createGitTagSchema: () => createGitTagSchema,
   createProjectSchema: () => createProjectSchema,
   currentBranchProjectSchema: () => currentBranchProjectSchema,
+  currentTimestamp: () => currentTimestamp,
   dateValueDefinitionSchema: () => dateValueDefinitionSchema,
   datetimeValueDefinitionSchema: () => datetimeValueDefinitionSchema,
   default: () => ElekIoCore,
@@ -126,6 +127,7 @@ __export(src_exports, {
   serviceTypeSchema: () => serviceTypeSchema,
   setRemoteOriginUrlProjectSchema: () => setRemoteOriginUrlProjectSchema,
   setUserSchema: () => setUserSchema,
+  slug: () => slug,
   stringValueDefinitionSchema: () => stringValueDefinitionSchema,
   supportedAssetExtensionSchema: () => supportedAssetExtensionSchema,
   supportedAssetMimeTypeSchema: () => supportedAssetMimeTypeSchema,
@@ -151,6 +153,7 @@ __export(src_exports, {
   urlValueDefinitionSchema: () => urlValueDefinitionSchema,
   userFileSchema: () => userFileSchema,
   userSchema: () => userSchema,
+  uuid: () => uuid,
   uuidSchema: () => uuidSchema,
   valueContentReferenceBase: () => valueContentReferenceBase,
   valueContentReferenceSchema: () => valueContentReferenceSchema,
@@ -162,21 +165,9 @@ __export(src_exports, {
   valueSchema: () => valueSchema,
   versionSchema: () => versionSchema
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_node_exports);
 var import_fs_extra7 = __toESM(require("fs-extra"), 1);
 
-// src/service/AssetService.ts
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-var import_is_svg = __toESM(require("is-svg"), 1);
-
-// src/error/RequiredParameterMissingError.ts
-var RequiredParameterMissingError = class extends Error {
-  constructor(parameter) {
-    super(`Missing required parameter "${parameter}"`);
-    this.name = "RequiredParameterMissingError";
-  }
-};
-
 // src/schema/assetSchema.ts
 var import_zod3 = __toESM(require("zod"), 1);
 
@@ -388,161 +379,21 @@ var deleteAssetSchema = assetFileSchema.pick({
 });
 var countAssetsSchema = import_zod3.default.object({ projectId: uuidSchema.readonly() });
 
-// src/schema/serviceSchema.ts
-var import_zod5 = require("zod");
-
-// src/schema/gitSchema.ts
-var import_zod4 = require("zod");
-var gitRepositoryPathSchema = import_zod4.z.string();
-var gitSignatureSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  email: import_zod4.z.string()
-});
-var gitCommitSchema = import_zod4.z.object({
-  /**
-   * SHA-1 hash of the commit
-   */
-  hash: import_zod4.z.string(),
-  message: import_zod4.z.string(),
-  author: gitSignatureSchema,
-  timestamp: import_zod4.z.number(),
-  tag: import_zod4.z.string().nullable()
-});
-var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
-  GitCommitIconNative2["INIT"] = ":tada:";
-  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
-  GitCommitIconNative2["UPDATE"] = ":wrench:";
-  GitCommitIconNative2["DELETE"] = ":fire:";
-  return GitCommitIconNative2;
-})(GitCommitIconNative || {});
-var gitCommitIconSchema = import_zod4.z.nativeEnum(GitCommitIconNative);
-var gitInitOptionsSchema = import_zod4.z.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).
-   */
-  initialBranch: import_zod4.z.string()
-});
-var gitCloneOptionsSchema = import_zod4.z.object({
-  /**
-   * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
-   */
-  depth: import_zod4.z.number(),
-  /**
-   * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
-   */
-  singleBranch: import_zod4.z.boolean(),
-  /**
-   * 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: import_zod4.z.string()
-});
-var gitSwitchOptionsSchema = import_zod4.z.object({
-  /**
-   * If true, creates a new local branch and then switches to it
-   *
-   * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
-   */
-  isNew: import_zod4.z.boolean().optional()
-});
-var gitLogOptionsSchema = import_zod4.z.object({
-  /**
-   * Limit the result to given number of commits
-   */
-  limit: import_zod4.z.number().optional(),
-  /**
-   * Only list commits that are between given SHAs or tag names
-   *
-   * Note that the commits of from and to are not included in the result
-   */
-  between: import_zod4.z.object({
-    /**
-     * From the oldest commit
-     */
-    from: import_zod4.z.string(),
-    /**
-     * To the newest commit
-     *
-     * Defaults to the current HEAD
-     */
-    to: import_zod4.z.string().optional()
-  })
-});
-
-// src/schema/serviceSchema.ts
-var serviceTypeSchema = import_zod5.z.enum([
-  "Git",
-  "GitTag",
-  "User",
-  "Project",
-  "Asset",
-  "JsonFile",
-  "Search",
-  "Collection",
-  "Entry",
-  "Value"
-]);
-var listSchema = import_zod5.z.object({
-  projectId: uuidSchema,
-  limit: import_zod5.z.number().optional(),
-  offset: import_zod5.z.number().optional()
-});
-var listCollectionsSchema = listSchema;
-var listEntriesSchema = listSchema.extend({
-  collectionId: uuidSchema
-});
-var listAssetsSchema = listSchema;
-var listProjectsSchema = listSchema.omit({
-  projectId: true
-});
-var listGitTagsSchema = import_zod5.z.object({
-  path: gitRepositoryPathSchema
-});
-
-// src/util/index.ts
-var util_exports = {};
-__export(util_exports, {
-  assignDefaultIfMissing: () => assignDefaultIfMissing,
-  currentTimestamp: () => currentTimestamp,
-  files: () => files,
-  folders: () => folders,
-  fromPath: () => fromPath,
-  getDuplicates: () => getDuplicates,
-  getRelativePath: () => getRelativePath,
-  isNoError: () => isNoError,
-  notEmpty: () => notEmpty,
-  pathTo: () => pathTo,
-  returnResolved: () => returnResolved,
-  slug: () => slug,
-  spawnChildProcess: () => spawnChildProcess,
-  uuid: () => uuid,
-  workingDirectory: () => workingDirectory
-});
-var import_child_process = require("child_process");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-var import_lodash_es = require("lodash-es");
-var import_os = __toESM(require("os"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_slugify = __toESM(require("slugify"), 1);
-var import_uuid = require("uuid");
-
-// src/schema/projectSchema.ts
-var import_zod9 = require("zod");
-
 // src/schema/collectionSchema.ts
-var import_zod8 = __toESM(require("zod"), 1);
+var import_zod6 = __toESM(require("zod"), 1);
 
 // src/schema/entrySchema.ts
-var import_zod7 = __toESM(require("zod"), 1);
+var import_zod5 = __toESM(require("zod"), 1);
 
 // src/schema/valueSchema.ts
-var import_zod6 = __toESM(require("zod"), 1);
-var ValueTypeSchema = import_zod6.default.enum([
+var import_zod4 = __toESM(require("zod"), 1);
+var ValueTypeSchema = import_zod4.default.enum([
   "string",
   "number",
   "boolean",
   "reference"
 ]);
-var ValueInputTypeSchema = import_zod6.default.enum([
+var ValueInputTypeSchema = import_zod4.default.enum([
   // String
   "text",
   "textarea",
@@ -564,67 +415,67 @@ var ValueInputTypeSchema = import_zod6.default.enum([
   "entry"
   // 'sharedValue', // @todo
 ]);
-var ValueInputWidthSchema = import_zod6.default.enum(["12", "6", "4", "3"]);
-var ValueDefinitionBaseSchema = import_zod6.default.object({
+var ValueInputWidthSchema = import_zod4.default.enum(["12", "6", "4", "3"]);
+var ValueDefinitionBaseSchema = import_zod4.default.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
   description: translatableStringSchema,
-  isRequired: import_zod6.default.boolean(),
-  isDisabled: import_zod6.default.boolean(),
-  isUnique: import_zod6.default.boolean(),
+  isRequired: import_zod4.default.boolean(),
+  isDisabled: import_zod4.default.boolean(),
+  isUnique: import_zod4.default.boolean(),
   inputWidth: ValueInputWidthSchema
 });
 var StringValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
   {
-    valueType: import_zod6.default.literal(ValueTypeSchema.Enum.string),
-    defaultValue: import_zod6.default.string().nullable()
+    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string),
+    defaultValue: import_zod4.default.string().nullable()
   }
 );
 var textValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
   {
-    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.text),
-    min: import_zod6.default.number().nullable(),
-    max: import_zod6.default.number().nullable()
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.text),
+    min: import_zod4.default.number().nullable(),
+    max: import_zod4.default.number().nullable()
   }
 );
 var textareaValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.textarea),
-  min: import_zod6.default.number().nullable(),
-  max: import_zod6.default.number().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.textarea),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
 });
 var emailValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.email),
-  defaultValue: import_zod6.default.string().email().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.email),
+  defaultValue: import_zod4.default.string().email().nullable()
 });
 var urlValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.url),
-  defaultValue: import_zod6.default.string().url().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.url),
+  defaultValue: import_zod4.default.string().url().nullable()
 });
 var ipValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.ip),
-  defaultValue: import_zod6.default.string().ip().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.ip),
+  defaultValue: import_zod4.default.string().ip().nullable()
 });
 var dateValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
   {
-    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.date),
-    defaultValue: import_zod6.default.string().date().nullable()
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.date),
+    defaultValue: import_zod4.default.string().date().nullable()
   }
 );
 var timeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend(
   {
-    inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.time),
-    defaultValue: import_zod6.default.string().time().nullable()
+    inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.time),
+    defaultValue: import_zod4.default.string().time().nullable()
   }
 );
 var datetimeValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.datetime),
-  defaultValue: import_zod6.default.string().datetime().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.datetime),
+  defaultValue: import_zod4.default.string().datetime().nullable()
 });
 var telephoneValueDefinitionSchema = StringValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.telephone)
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.telephone)
   // defaultValue: z.string().e164(), @todo when zod v4 releases @see https://github.com/colinhacks/zod/pull/3476
 });
-var stringValueDefinitionSchema = import_zod6.default.union([
+var stringValueDefinitionSchema = import_zod4.default.union([
   textValueDefinitionSchema,
   textareaValueDefinitionSchema,
   emailValueDefinitionSchema,
@@ -637,50 +488,50 @@ var stringValueDefinitionSchema = import_zod6.default.union([
 ]);
 var NumberValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend(
   {
-    valueType: import_zod6.default.literal(ValueTypeSchema.Enum.number),
-    min: import_zod6.default.number().nullable(),
-    max: import_zod6.default.number().nullable(),
-    isUnique: import_zod6.default.literal(false),
-    defaultValue: import_zod6.default.number().nullable()
+    valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number),
+    min: import_zod4.default.number().nullable(),
+    max: import_zod4.default.number().nullable(),
+    isUnique: import_zod4.default.literal(false),
+    defaultValue: import_zod4.default.number().nullable()
   }
 );
 var numberValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.number)
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.number)
 });
 var rangeValueDefinitionSchema = NumberValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.range),
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.range),
   // Overwrite from nullable to required because a range needs min, max and default to work and is required, since it always returns a number
-  isRequired: import_zod6.default.literal(true),
-  min: import_zod6.default.number(),
-  max: import_zod6.default.number(),
-  defaultValue: import_zod6.default.number()
+  isRequired: import_zod4.default.literal(true),
+  min: import_zod4.default.number(),
+  max: import_zod4.default.number(),
+  defaultValue: import_zod4.default.number()
 });
 var BooleanValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.boolean),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.boolean),
   // Overwrite from nullable to required because a boolean needs a default to work and is required, since it always is either true or false
-  isRequired: import_zod6.default.literal(true),
-  defaultValue: import_zod6.default.boolean(),
-  isUnique: import_zod6.default.literal(false)
+  isRequired: import_zod4.default.literal(true),
+  defaultValue: import_zod4.default.boolean(),
+  isUnique: import_zod4.default.literal(false)
 });
 var toggleValueDefinitionSchema = BooleanValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.toggle)
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.toggle)
 });
 var ReferenceValueDefinitionBaseSchema = ValueDefinitionBaseSchema.extend({
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.reference)
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference)
 });
 var assetValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.asset),
-  allowedMimeTypes: import_zod6.default.array(supportedAssetMimeTypeSchema).min(1),
-  min: import_zod6.default.number().nullable(),
-  max: import_zod6.default.number().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.asset),
+  allowedMimeTypes: import_zod4.default.array(supportedAssetMimeTypeSchema).min(1),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
 });
 var entryValueDefinitionSchema = ReferenceValueDefinitionBaseSchema.extend({
-  inputType: import_zod6.default.literal(ValueInputTypeSchema.Enum.entry),
-  ofCollections: import_zod6.default.array(uuidSchema),
-  min: import_zod6.default.number().nullable(),
-  max: import_zod6.default.number().nullable()
+  inputType: import_zod4.default.literal(ValueInputTypeSchema.Enum.entry),
+  ofCollections: import_zod4.default.array(uuidSchema),
+  min: import_zod4.default.number().nullable(),
+  max: import_zod4.default.number().nullable()
 });
-var valueDefinitionSchema = import_zod6.default.union([
+var valueDefinitionSchema = import_zod4.default.union([
   stringValueDefinitionSchema,
   numberValueDefinitionSchema,
   rangeValueDefinitionSchema,
@@ -689,65 +540,65 @@ var valueDefinitionSchema = import_zod6.default.union([
   entryValueDefinitionSchema
   // sharedValueDefinitionSchema,
 ]);
-var valueContentReferenceBase = import_zod6.default.object({
+var valueContentReferenceBase = import_zod4.default.object({
   id: uuidSchema
 });
 var valueContentReferenceWithLanguageBase = valueContentReferenceBase.extend({
   language: supportedLanguageSchema
 });
 var valueContentReferenceToAssetSchema = valueContentReferenceWithLanguageBase.extend({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.asset)
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.asset)
 });
 var valueContentReferenceToCollectionSchema = valueContentReferenceBase.extend({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.collection)
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.collection)
 });
 var valueContentReferenceToEntrySchema = valueContentReferenceBase.extend({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.entry)
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.entry)
 });
-var valueContentReferenceSchema = import_zod6.default.union([
+var valueContentReferenceSchema = import_zod4.default.union([
   valueContentReferenceToAssetSchema,
   valueContentReferenceToCollectionSchema,
   valueContentReferenceToEntrySchema
   // valueContentReferenceToSharedValueSchema,
 ]);
-var resolvedValueContentReferenceSchema = import_zod6.default.union([
+var resolvedValueContentReferenceSchema = import_zod4.default.union([
   assetSchema,
-  import_zod6.default.lazy(() => entrySchema)
+  import_zod4.default.lazy(() => entrySchema)
   // Circular dependency / recursive type @see https://github.com/colinhacks/zod?tab=readme-ov-file#recursive-types
   // resolvedValueContentReferenceToSharedValueSchema,
 ]);
-var directValueBaseSchema = import_zod6.default.object({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.value).readonly(),
+var directValueBaseSchema = import_zod4.default.object({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
   definitionId: uuidSchema.readonly()
 });
 var directStringValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.string).readonly(),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.string).readonly(),
   content: translatableStringSchema
 });
 var directNumberValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.number).readonly(),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.number).readonly(),
   content: translatableNumberSchema
 });
 var directBooleanValueSchema = directValueBaseSchema.extend({
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.boolean).readonly(),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.boolean).readonly(),
   content: translatableBooleanSchema
 });
-var directValueSchema = import_zod6.default.union([
+var directValueSchema = import_zod4.default.union([
   directStringValueSchema,
   directNumberValueSchema,
   directBooleanValueSchema
 ]);
-var referencedValueSchema = import_zod6.default.object({
-  objectType: import_zod6.default.literal(objectTypeSchema.Enum.value).readonly(),
+var referencedValueSchema = import_zod4.default.object({
+  objectType: import_zod4.default.literal(objectTypeSchema.Enum.value).readonly(),
   definitionId: uuidSchema.readonly(),
-  valueType: import_zod6.default.literal(ValueTypeSchema.Enum.reference).readonly(),
+  valueType: import_zod4.default.literal(ValueTypeSchema.Enum.reference).readonly(),
   content: translatableArrayOf(valueContentReferenceSchema)
 });
-var valueSchema = import_zod6.default.union([directValueSchema, referencedValueSchema]);
+var valueSchema = import_zod4.default.union([directValueSchema, referencedValueSchema]);
 var resolvedReferencedValueSchema = referencedValueSchema.extend({
   content: translatableArrayOf(resolvedValueContentReferenceSchema)
 });
-var resolvedValueSchema = import_zod6.default.union([
+var resolvedValueSchema = import_zod4.default.union([
   directValueSchema,
   resolvedReferencedValueSchema
 ]);
@@ -769,10 +620,10 @@ function getValueContentSchemaFromDefinition(definition) {
   }
 }
 function getBooleanValueContentSchema(definition) {
-  return import_zod6.default.boolean();
+  return import_zod4.default.boolean();
 }
 function getNumberValueContentSchema(definition) {
-  let schema = import_zod6.default.number();
+  let schema = import_zod4.default.number();
   if (definition.min) {
     schema = schema.min(definition.min);
   }
@@ -785,7 +636,7 @@ function getNumberValueContentSchema(definition) {
   return schema;
 }
 function getStringValueContentSchema(definition) {
-  let schema = import_zod6.default.string().trim();
+  let schema = import_zod4.default.string().trim();
   if ("min" in definition && definition.min) {
     schema = schema.min(definition.min);
   }
@@ -824,12 +675,12 @@ function getReferenceValueContentSchema(definition) {
   switch (definition.inputType) {
     case ValueInputTypeSchema.Enum.asset:
       {
-        schema = import_zod6.default.array(valueContentReferenceToAssetSchema);
+        schema = import_zod4.default.array(valueContentReferenceToAssetSchema);
       }
       break;
     case ValueInputTypeSchema.Enum.entry:
       {
-        schema = import_zod6.default.array(valueContentReferenceToEntrySchema);
+        schema = import_zod4.default.array(valueContentReferenceToEntrySchema);
       }
       break;
   }
@@ -847,11 +698,11 @@ function getReferenceValueContentSchema(definition) {
 
 // src/schema/entrySchema.ts
 var entryFileSchema = baseFileSchema.extend({
-  objectType: import_zod7.default.literal(objectTypeSchema.Enum.entry).readonly(),
-  values: import_zod7.default.array(valueSchema)
+  objectType: import_zod5.default.literal(objectTypeSchema.Enum.entry).readonly(),
+  values: import_zod5.default.array(valueSchema)
 });
 var entrySchema = entryFileSchema.extend({
-  values: import_zod7.default.array(import_zod7.default.lazy(() => resolvedValueSchema))
+  values: import_zod5.default.array(import_zod5.default.lazy(() => resolvedValueSchema))
 });
 var entryExportSchema = entrySchema.extend({});
 var createEntrySchema = entryFileSchema.omit({
@@ -862,9 +713,9 @@ var createEntrySchema = entryFileSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly(),
-  values: import_zod7.default.array(valueSchema)
+  values: import_zod5.default.array(valueSchema)
 });
-var readEntrySchema = import_zod7.default.object({
+var readEntrySchema = import_zod5.default.object({
   id: uuidSchema.readonly(),
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly()
@@ -878,29 +729,29 @@ var updateEntrySchema = entrySchema.omit({
   collectionId: uuidSchema.readonly()
 });
 var deleteEntrySchema = readEntrySchema.extend({});
-var countEntriesSchema = import_zod7.default.object({
+var countEntriesSchema = import_zod5.default.object({
   projectId: uuidSchema.readonly(),
   collectionId: uuidSchema.readonly()
 });
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
-  objectType: import_zod8.default.literal(objectTypeSchema.Enum.collection).readonly(),
-  name: import_zod8.default.object({
+  objectType: import_zod6.default.literal(objectTypeSchema.Enum.collection).readonly(),
+  name: import_zod6.default.object({
     singular: translatableStringSchema,
     plural: translatableStringSchema
   }),
-  slug: import_zod8.default.object({
-    singular: import_zod8.default.string(),
-    plural: import_zod8.default.string()
+  slug: import_zod6.default.object({
+    singular: import_zod6.default.string(),
+    plural: import_zod6.default.string()
   }),
   description: translatableStringSchema,
   icon: supportedIconSchema,
-  valueDefinitions: import_zod8.default.array(valueDefinitionSchema)
+  valueDefinitions: import_zod6.default.array(valueDefinitionSchema)
 });
 var collectionSchema = collectionFileSchema.extend({});
 var collectionExportSchema = collectionSchema.extend({
-  entries: import_zod8.default.array(entryExportSchema)
+  entries: import_zod6.default.array(entryExportSchema)
 });
 var createCollectionSchema = collectionSchema.omit({
   id: true,
@@ -910,7 +761,7 @@ var createCollectionSchema = collectionSchema.omit({
 }).extend({
   projectId: uuidSchema.readonly()
 });
-var readCollectionSchema = import_zod8.default.object({
+var readCollectionSchema = import_zod6.default.object({
   id: uuidSchema.readonly(),
   projectId: uuidSchema.readonly()
 });
@@ -925,19 +776,149 @@ var updateCollectionSchema = collectionFileSchema.pick({
   projectId: uuidSchema.readonly()
 });
 var deleteCollectionSchema = readCollectionSchema.extend({});
-var countCollectionsSchema = import_zod8.default.object({
+var countCollectionsSchema = import_zod6.default.object({
   projectId: uuidSchema.readonly()
 });
 
+// src/schema/coreSchema.ts
+var import_zod7 = require("zod");
+var elekIoCoreOptionsSchema = import_zod7.z.object({
+  /**
+   * The environment elek.io Core is currently running in
+   */
+  environment: environmentSchema,
+  /**
+   * The current version of elek.io Core
+   */
+  version: versionSchema,
+  file: import_zod7.z.object({
+    json: import_zod7.z.object({
+      /**
+       * If set, adds indentation with spaces (number) or escape character (string)
+       * and line break characters to saved JSON files on disk, to make them easier to read.
+       * Defaults to 2 spaces of indentation.
+       */
+      indentation: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.string()])
+    })
+  })
+});
+var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
+  version: true
+}).partial({
+  environment: true,
+  file: true
+}).optional();
+
+// src/schema/gitSchema.ts
+var import_zod8 = require("zod");
+var gitRepositoryPathSchema = import_zod8.z.string();
+var gitSignatureSchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  email: import_zod8.z.string()
+});
+var gitCommitSchema = import_zod8.z.object({
+  /**
+   * SHA-1 hash of the commit
+   */
+  hash: import_zod8.z.string(),
+  message: import_zod8.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod8.z.number(),
+  tag: import_zod8.z.string().nullable()
+});
+var GitCommitIconNative = /* @__PURE__ */ ((GitCommitIconNative2) => {
+  GitCommitIconNative2["INIT"] = ":tada:";
+  GitCommitIconNative2["CREATE"] = ":heavy_plus_sign:";
+  GitCommitIconNative2["UPDATE"] = ":wrench:";
+  GitCommitIconNative2["DELETE"] = ":fire:";
+  return GitCommitIconNative2;
+})(GitCommitIconNative || {});
+var gitCommitIconSchema = import_zod8.z.nativeEnum(GitCommitIconNative);
+var gitInitOptionsSchema = import_zod8.z.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).
+   */
+  initialBranch: import_zod8.z.string()
+});
+var gitCloneOptionsSchema = import_zod8.z.object({
+  /**
+   * Create a shallow clone with a history truncated to the specified number of commits. Implies --single-branch unless --no-single-branch is given to fetch the histories near the tips of all branches. If you want to clone submodules shallowly, also pass --shallow-submodules.
+   */
+  depth: import_zod8.z.number(),
+  /**
+   * Clone only the history leading to the tip of a single branch, either specified by the --branch option or the primary branch remote’s HEAD points at. Further fetches into the resulting repository will only update the remote-tracking branch for the branch this option was used for the initial cloning. If the HEAD at the remote did not point at any branch when --single-branch clone was made, no remote-tracking branch is created.
+   */
+  singleBranch: import_zod8.z.boolean(),
+  /**
+   * 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: import_zod8.z.string()
+});
+var gitSwitchOptionsSchema = import_zod8.z.object({
+  /**
+   * If true, creates a new local branch and then switches to it
+   *
+   * @see https://git-scm.com/docs/git-switch#Documentation/git-switch.txt---createltnew-branchgt
+   */
+  isNew: import_zod8.z.boolean().optional()
+});
+var gitLogOptionsSchema = import_zod8.z.object({
+  /**
+   * Limit the result to given number of commits
+   */
+  limit: import_zod8.z.number().optional(),
+  /**
+   * Only list commits that are between given SHAs or tag names
+   *
+   * Note that the commits of from and to are not included in the result
+   */
+  between: import_zod8.z.object({
+    /**
+     * From the oldest commit
+     */
+    from: import_zod8.z.string(),
+    /**
+     * To the newest commit
+     *
+     * Defaults to the current HEAD
+     */
+    to: import_zod8.z.string().optional()
+  })
+});
+
+// src/schema/gitTagSchema.ts
+var import_zod9 = require("zod");
+var gitTagSchema = import_zod9.z.object({
+  id: uuidSchema,
+  message: import_zod9.z.string(),
+  author: gitSignatureSchema,
+  timestamp: import_zod9.z.number()
+});
+var createGitTagSchema = gitTagSchema.pick({
+  message: true
+}).extend({
+  path: gitRepositoryPathSchema,
+  hash: gitCommitSchema.shape.hash.optional()
+});
+var readGitTagSchema = import_zod9.z.object({
+  path: gitRepositoryPathSchema,
+  id: uuidSchema.readonly()
+});
+var deleteGitTagSchema = readGitTagSchema.extend({});
+var countGitTagsSchema = import_zod9.z.object({
+  path: gitRepositoryPathSchema
+});
+
 // src/schema/projectSchema.ts
-var projectStatusSchema = import_zod9.z.enum(["foo", "bar", "todo"]);
-var projectSettingsSchema = import_zod9.z.object({
-  language: import_zod9.z.object({
+var import_zod10 = require("zod");
+var projectStatusSchema = import_zod10.z.enum(["foo", "bar", "todo"]);
+var projectSettingsSchema = import_zod10.z.object({
+  language: import_zod10.z.object({
     default: supportedLanguageSchema,
-    supported: import_zod9.z.array(supportedLanguageSchema)
+    supported: import_zod10.z.array(supportedLanguageSchema)
   })
 });
-var projectFolderSchema = import_zod9.z.enum([
+var projectFolderSchema = import_zod10.z.enum([
   "assets",
   "collections",
   "shared-values",
@@ -947,18 +928,18 @@ var projectFolderSchema = import_zod9.z.enum([
   // 'theme',
 ]);
 var projectFileSchema = baseFileSchema.extend({
-  objectType: import_zod9.z.literal(objectTypeSchema.Enum.project).readonly(),
+  objectType: import_zod10.z.literal(objectTypeSchema.Enum.project).readonly(),
   coreVersion: versionSchema,
-  name: import_zod9.z.string().trim().min(1, "shared.projectNameRequired"),
-  description: import_zod9.z.string().trim().min(1, "shared.projectDescriptionRequired"),
+  name: import_zod10.z.string().trim().min(1, "shared.projectNameRequired"),
+  description: import_zod10.z.string().trim().min(1, "shared.projectDescriptionRequired"),
   version: versionSchema,
   status: projectStatusSchema,
   settings: projectSettingsSchema
 });
 var projectSchema = projectFileSchema.extend({});
 var projectExportSchema = projectSchema.extend({
-  assets: import_zod9.z.array(assetExportSchema),
-  collections: import_zod9.z.array(collectionExportSchema)
+  assets: import_zod10.z.array(assetExportSchema),
+  collections: import_zod10.z.array(collectionExportSchema)
 });
 var createProjectSchema = projectSchema.pick({
   name: true,
@@ -968,7 +949,7 @@ var createProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var readProjectSchema = import_zod9.z.object({
+var readProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
 var updateProjectSchema = projectSchema.pick({
@@ -981,11 +962,11 @@ var updateProjectSchema = projectSchema.pick({
   description: true,
   settings: true
 });
-var upgradeProjectSchema = import_zod9.z.object({
+var upgradeProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
 var deleteProjectSchema = readProjectSchema.extend({});
-var projectUpgradeSchema = import_zod9.z.object({
+var projectUpgradeSchema = import_zod10.z.object({
   /**
    * The Core version the Project will be upgraded to
    */
@@ -993,79 +974,161 @@ var projectUpgradeSchema = import_zod9.z.object({
   /**
    * Function that will be executed in the process of upgrading a Project
    */
-  run: import_zod9.z.function().args(projectFileSchema).returns(import_zod9.z.promise(import_zod9.z.void()))
+  run: import_zod10.z.function().args(projectFileSchema).returns(import_zod10.z.promise(import_zod10.z.void()))
 });
-var cloneProjectSchema = import_zod9.z.object({
-  url: import_zod9.z.string()
+var cloneProjectSchema = import_zod10.z.object({
+  url: import_zod10.z.string()
 });
-var listBranchesProjectSchema = import_zod9.z.object({
+var listBranchesProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
-var currentBranchProjectSchema = import_zod9.z.object({
+var currentBranchProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
-var switchBranchProjectSchema = import_zod9.z.object({
+var switchBranchProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly(),
-  branch: import_zod9.z.string(),
+  branch: import_zod10.z.string(),
   options: gitSwitchOptionsSchema.optional()
 });
-var getRemoteOriginUrlProjectSchema = import_zod9.z.object({
+var getRemoteOriginUrlProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
-var setRemoteOriginUrlProjectSchema = import_zod9.z.object({
+var setRemoteOriginUrlProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly(),
-  url: import_zod9.z.string()
+  url: import_zod10.z.string()
 });
-var getChangesProjectSchema = import_zod9.z.object({
+var getChangesProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
-var synchronizeProjectSchema = import_zod9.z.object({
+var synchronizeProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly()
 });
-var searchProjectSchema = import_zod9.z.object({
+var searchProjectSchema = import_zod10.z.object({
   id: uuidSchema.readonly(),
-  query: import_zod9.z.string(),
+  query: import_zod10.z.string(),
   language: supportedLanguageSchema,
-  type: import_zod9.z.array(objectTypeSchema).optional()
+  type: import_zod10.z.array(objectTypeSchema).optional()
 });
 
-// src/util/index.ts
-var Slugify = import_slugify.default.default || import_slugify.default;
-function uuid() {
-  return (0, import_uuid.v4)();
-}
-function currentTimestamp() {
-  return Math.floor(Date.now() / 1e3);
-}
-function slug(string) {
-  return Slugify(string, {
-    replacement: "-",
-    // replace spaces with replacement character, defaults to `-`
-    remove: void 0,
-    // remove characters that match regex, defaults to `undefined`
-    lower: true,
-    // convert to lower case, defaults to `false`
-    strict: true
-    // strip special characters except replacement, defaults to `false`
-  });
-}
-var workingDirectory = import_path.default.join(import_os.default.homedir(), "elek.io");
-var pathTo = {
-  tmp: import_path.default.join(workingDirectory, "tmp"),
-  userFile: import_path.default.join(workingDirectory, "user.json"),
-  // logs: Path.join(workingDirectory, 'logs'),
-  projects: import_path.default.join(workingDirectory, "projects"),
-  project: (projectId) => {
-    return import_path.default.join(pathTo.projects, projectId);
-  },
-  projectFile: (projectId) => {
-    return import_path.default.join(pathTo.project(projectId), "project.json");
-  },
-  // projectLogs: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
-  // },
-  // public: (projectId: string): string => {
-  //   return Path.join(pathTo.project(projectId), 'public');
+// src/schema/serviceSchema.ts
+var import_zod11 = require("zod");
+var serviceTypeSchema = import_zod11.z.enum([
+  "Git",
+  "GitTag",
+  "User",
+  "Project",
+  "Asset",
+  "JsonFile",
+  "Search",
+  "Collection",
+  "Entry",
+  "Value"
+]);
+var listSchema = import_zod11.z.object({
+  projectId: uuidSchema,
+  limit: import_zod11.z.number().optional(),
+  offset: import_zod11.z.number().optional()
+});
+var listCollectionsSchema = listSchema;
+var listEntriesSchema = listSchema.extend({
+  collectionId: uuidSchema
+});
+var listAssetsSchema = listSchema;
+var listProjectsSchema = listSchema.omit({
+  projectId: true
+});
+var listGitTagsSchema = import_zod11.z.object({
+  path: gitRepositoryPathSchema
+});
+
+// src/schema/userSchema.ts
+var import_zod12 = __toESM(require("zod"), 1);
+var UserTypeSchema = import_zod12.default.enum(["local", "cloud"]);
+var baseUserSchema = gitSignatureSchema.extend({
+  userType: UserTypeSchema,
+  language: supportedLanguageSchema
+});
+var localUserSchema = baseUserSchema.extend({
+  userType: import_zod12.default.literal(UserTypeSchema.Enum.local)
+});
+var cloudUserSchema = baseUserSchema.extend({
+  userType: import_zod12.default.literal(UserTypeSchema.Enum.cloud),
+  id: uuidSchema
+});
+var userFileSchema = import_zod12.default.union([localUserSchema, cloudUserSchema]);
+var userSchema = userFileSchema;
+var setUserSchema = userSchema;
+
+// src/error/GitError.ts
+var GitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitError";
+  }
+};
+
+// src/error/NoCurrentUserError.ts
+var NoCurrentUserError = class extends Error {
+  constructor() {
+    super("Make sure to set a User via Core before using other methods");
+    this.name = "NoCurrentUserError";
+  }
+};
+
+// src/error/ProjectUpgradeError.ts
+var ProjectUpgradeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectUpgradeError";
+  }
+};
+
+// src/error/RequiredParameterMissingError.ts
+var RequiredParameterMissingError = class extends Error {
+  constructor(parameter) {
+    super(`Missing required parameter "${parameter}"`);
+    this.name = "RequiredParameterMissingError";
+  }
+};
+
+// src/util/node.ts
+var node_exports = {};
+__export(node_exports, {
+  assignDefaultIfMissing: () => assignDefaultIfMissing,
+  files: () => files,
+  folders: () => folders,
+  fromPath: () => fromPath,
+  getDuplicates: () => getDuplicates,
+  getRelativePath: () => getRelativePath,
+  isNoError: () => isNoError,
+  notEmpty: () => notEmpty,
+  pathTo: () => pathTo,
+  returnResolved: () => returnResolved,
+  spawnChildProcess: () => spawnChildProcess,
+  workingDirectory: () => workingDirectory
+});
+var import_child_process = require("child_process");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_lodash_es = require("lodash-es");
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var workingDirectory = import_path.default.join(import_os.default.homedir(), "elek.io");
+var pathTo = {
+  tmp: import_path.default.join(workingDirectory, "tmp"),
+  userFile: import_path.default.join(workingDirectory, "user.json"),
+  // logs: Path.join(workingDirectory, 'logs'),
+  projects: import_path.default.join(workingDirectory, "projects"),
+  project: (projectId) => {
+    return import_path.default.join(pathTo.projects, projectId);
+  },
+  projectFile: (projectId) => {
+    return import_path.default.join(pathTo.project(projectId), "project.json");
+  },
+  // projectLogs: (projectId: string): string => {
+  //   return Path.join(pathTo.project(projectId), projectFolderSchema.Enum.logs);
+  // },
+  // public: (projectId: string): string => {
+  //   return Path.join(pathTo.project(projectId), 'public');
   // },
   lfs: (projectId) => {
     return import_path.default.join(pathTo.project(projectId), projectFolderSchema.Enum.lfs);
@@ -1313,269 +1376,465 @@ var AbstractCrudService = class {
   }
 };
 
-// src/service/GitService.ts
-var import_dugite = require("dugite");
-var import_os3 = require("os");
-var import_p_queue = __toESM(require("p-queue"), 1);
-
-// src/error/GitError.ts
-var GitError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GitError";
-  }
-};
-
-// src/error/NoCurrentUserError.ts
-var NoCurrentUserError = class extends Error {
-  constructor() {
-    super("Make sure to set a User via Core before using other methods");
-    this.name = "NoCurrentUserError";
-  }
-};
-
-// src/service/GitTagService.ts
-var import_os2 = require("os");
+// src/service/AssetService.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_is_svg = __toESM(require("is-svg"), 1);
 
-// src/schema/gitTagSchema.ts
-var import_zod10 = require("zod");
-var gitTagSchema = import_zod10.z.object({
-  id: uuidSchema,
-  message: import_zod10.z.string(),
-  author: gitSignatureSchema,
-  timestamp: import_zod10.z.number()
-});
-var createGitTagSchema = gitTagSchema.pick({
-  message: true
-}).extend({
-  path: gitRepositoryPathSchema,
-  hash: gitCommitSchema.shape.hash.optional()
-});
-var readGitTagSchema = import_zod10.z.object({
-  path: gitRepositoryPathSchema,
-  id: uuidSchema.readonly()
-});
-var deleteGitTagSchema = readGitTagSchema.extend({});
-var countGitTagsSchema = import_zod10.z.object({
-  path: gitRepositoryPathSchema
-});
+// src/util/shared.ts
+var import_slugify = __toESM(require("slugify"), 1);
+var import_uuid = require("uuid");
+var Slugify = import_slugify.default.default || import_slugify.default;
+function uuid() {
+  return (0, import_uuid.v4)();
+}
+function currentTimestamp() {
+  return Math.floor(Date.now() / 1e3);
+}
+function slug(string) {
+  return Slugify(string, {
+    replacement: "-",
+    // replace spaces with replacement character, defaults to `-`
+    remove: void 0,
+    // remove characters that match regex, defaults to `undefined`
+    lower: true,
+    // convert to lower case, defaults to `false`
+    strict: true
+    // strip special characters except replacement, defaults to `false`
+  });
+}
 
-// src/service/GitTagService.ts
-var GitTagService = class extends AbstractCrudService {
-  constructor(options, git) {
-    super(serviceTypeSchema.Enum.GitTag, options);
-    this.git = git;
-  }
-  /**
-   * Creates a new tag
-   *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
-   */
-  async create(props) {
-    createGitTagSchema.parse(props);
-    const id = uuid();
-    let args = ["tag", "--annotate", id];
-    if (props.hash) {
-      args = [...args, props.hash];
-    }
-    args = [...args, "-m", props.message];
-    await this.git(props.path, args);
-    const tag = await this.read({ path: props.path, id });
-    return tag;
+// src/service/JsonFileService.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var JsonFileService = class extends AbstractCrudService {
+  constructor(options) {
+    super(serviceTypeSchema.Enum.JsonFile, options);
+    this.cache = /* @__PURE__ */ new Map();
   }
   /**
-   * Returns a tag by ID
+   * Creates a new file on disk. Fails if path already exists
    *
-   * Internally uses list() but only returns the tag with matching ID.
+   * @param data Data to write into the file
+   * @param path Path to write the file to
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  async read(props) {
-    readGitTagSchema.parse(props);
-    const tags = await this.list({ path: props.path });
-    const tag = tags.list.find((tag2) => {
-      return tag2.id === props.id;
+  async create(data, path, schema) {
+    const parsedData = schema.parse(data);
+    const string = this.serialize(parsedData);
+    await import_fs_extra2.default.writeFile(path, string, {
+      flag: "wx",
+      encoding: "utf8"
     });
-    if (!tag) {
-      throw new GitError(
-        `Provided tag with UUID "${props.id}" did not match any known tags`
-      );
-    }
-    return tag;
+    this.cache.set(path, parsedData);
+    return parsedData;
   }
   /**
-   * Updating a git tag is not supported.
-   * Please delete the old and create a new one
+   * Reads the content of a file on disk. Fails if path does not exist
    *
-   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
+   * @param path Path to read the file from
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  async update() {
-    throw new Error(
-      "Updating a git tag is not supported. Please delete the old and create a new one"
-    );
+  async read(path, schema) {
+    if (this.cache.has(path)) {
+      return this.cache.get(path);
+    }
+    const data = await import_fs_extra2.default.readFile(path, {
+      flag: "r",
+      encoding: "utf8"
+    });
+    const json = this.deserialize(data);
+    const parsedData = schema.parse(json);
+    this.cache.set(path, parsedData);
+    return parsedData;
   }
   /**
-   * Deletes a tag
+   * Overwrites an existing file on disk
    *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+   * @todo Check how to error out if the file does not exist already
    *
-   * @param path  Path to the repository
-   * @param id    UUID of the tag to delete
+   * @param data Data to write into the file
+   * @param path Path to the file to overwrite
+   * @param schema Schema of the file to validate against
+   * @returns Validated content of the file from disk
    */
-  async delete(props) {
-    deleteGitTagSchema.parse(props);
-    const args = ["tag", "--delete", props.id];
-    await this.git(props.path, args);
+  async update(data, path, schema) {
+    const parsedData = schema.parse(data);
+    const string = this.serialize(parsedData);
+    await import_fs_extra2.default.writeFile(path, string, {
+      flag: "w",
+      encoding: "utf8"
+    });
+    this.cache.set(path, parsedData);
+    return parsedData;
+  }
+  serialize(data) {
+    return JSON.stringify(data, null, this.options.file.json.indentation);
+  }
+  deserialize(data) {
+    return JSON.parse(data);
+  }
+};
+
+// src/service/AssetService.ts
+var AssetService = class extends AbstractCrudService {
+  constructor(options, jsonFileService, gitService) {
+    super(serviceTypeSchema.Enum.Asset, options);
+    this.jsonFileService = jsonFileService;
+    this.gitService = gitService;
   }
   /**
-   * Gets all local tags or filter them by pattern
-   *
-   * They are sorted by authordate of the commit, not the timestamp the tag is created.
-   * This ensures tags are sorted correctly in the timeline of their commits.
+   * Creates a new Asset
+   */
+  async create(props) {
+    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 assetPath = pathTo.asset(
+      props.projectId,
+      id,
+      props.language,
+      fileType.extension
+    );
+    const assetFilePath = pathTo.assetFile(props.projectId, id, props.language);
+    const assetFile = {
+      ...props,
+      objectType: "asset",
+      id,
+      created: currentTimestamp(),
+      updated: null,
+      extension: fileType.extension,
+      mimeType: fileType.mimeType,
+      size
+    };
+    try {
+      await import_fs_extra3.default.copyFile(props.filePath, assetPath);
+      await this.jsonFileService.create(
+        assetFile,
+        assetFilePath,
+        assetFileSchema
+      );
+    } catch (error) {
+      await this.delete({ ...assetFile, projectId: props.projectId });
+      throw error;
+    }
+    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.create);
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Returns an Asset by ID and language
+   */
+  async read(props) {
+    readAssetSchema.parse(props);
+    const assetFile = await this.jsonFileService.read(
+      pathTo.assetFile(props.projectId, props.id, props.language),
+      assetFileSchema
+    );
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Updates given Asset
    *
-   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
+   * Use the optional "newFilePath" prop to update the Asset itself
+   */
+  async update(props) {
+    updateAssetSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const assetFilePath = pathTo.assetFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    const prevAssetFile = await this.read(props);
+    const assetFile = {
+      ...prevAssetFile,
+      ...props,
+      updated: currentTimestamp()
+    };
+    if (props.newFilePath) {
+      const fileType = await this.getSupportedFileTypeOrThrow(
+        props.newFilePath
+      );
+      const size = await this.getAssetSize(props.newFilePath);
+      const prevAssetPath = pathTo.asset(
+        props.projectId,
+        props.id,
+        props.language,
+        prevAssetFile.extension
+      );
+      const assetPath = pathTo.asset(
+        props.projectId,
+        props.id,
+        props.language,
+        fileType.extension
+      );
+      await import_fs_extra3.default.remove(prevAssetPath);
+      await import_fs_extra3.default.copyFile(props.newFilePath, assetPath);
+      assetFile.extension = fileType.extension;
+      assetFile.mimeType = fileType.mimeType;
+      assetFile.size = size;
+    }
+    await this.jsonFileService.update(
+      assetFile,
+      assetFilePath,
+      assetFileSchema
+    );
+    await this.gitService.add(projectPath, [assetFilePath]);
+    await this.gitService.commit(projectPath, this.gitMessage.update);
+    return this.toAsset(props.projectId, assetFile);
+  }
+  /**
+   * Deletes given Asset
    */
+  async delete(props) {
+    deleteAssetSchema.parse(props);
+    const projectPath = pathTo.project(props.projectId);
+    const assetFilePath = pathTo.assetFile(
+      props.projectId,
+      props.id,
+      props.language
+    );
+    const assetPath = pathTo.asset(
+      props.projectId,
+      props.id,
+      props.language,
+      props.extension
+    );
+    await import_fs_extra3.default.remove(assetPath);
+    await import_fs_extra3.default.remove(assetFilePath);
+    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
+    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  }
   async list(props) {
-    listGitTagsSchema.parse(props);
-    let args = ["tag", "--list"];
-    args = [
-      ...args,
-      "--sort=-*authordate",
-      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
-    ];
-    const result = await this.git(props.path, args);
-    const noEmptyLinesArr = result.stdout.split(import_os2.EOL).filter((line) => {
-      return line.trim() !== "";
-    });
-    const lineObjArr = noEmptyLinesArr.map((line) => {
-      const lineArray = line.split("|");
-      return {
-        id: lineArray[0],
-        message: lineArray[1],
-        author: {
-          name: lineArray[2],
-          email: lineArray[3]
-        },
-        timestamp: parseInt(lineArray[4])
-      };
-    });
-    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
+    listAssetsSchema.parse(props);
+    const offset = props.offset || 0;
+    const limit = props.limit || 15;
+    const assetReferences = await this.listReferences(
+      objectTypeSchema.Enum.asset,
+      props.projectId
+    );
+    const partialAssetReferences = assetReferences.slice(offset, limit);
+    const assets = await returnResolved(
+      partialAssetReferences.map((assetReference) => {
+        if (!assetReference.language) {
+          throw new RequiredParameterMissingError("language");
+        }
+        return this.read({
+          projectId: props.projectId,
+          id: assetReference.id,
+          language: assetReference.language
+        });
+      })
+    );
     return {
-      total: gitTags.length,
-      limit: 0,
-      offset: 0,
-      list: gitTags
+      total: assetReferences.length,
+      limit,
+      offset,
+      list: assets
     };
   }
+  async count(props) {
+    countAssetsSchema.parse(props);
+    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
+    return count;
+  }
   /**
-   * Returns the total number of tags inside given repository
+   * Checks if given object is of type Asset
+   */
+  isAsset(obj) {
+    return assetSchema.safeParse(obj).success;
+  }
+  /**
+   * Returns the size of an Asset in bytes
    *
-   * Internally uses list(), so do not use count()
-   * in conjuncion with it to avoid multiple git calls.
+   * @param path Path of the Asset to get the size from
+   */
+  async getAssetSize(path) {
+    return (await import_fs_extra3.default.stat(path)).size;
+  }
+  /**
+   * Creates an Asset from given AssetFile
    *
-   * @param path Path to the repository
+   * @param projectId   The project's ID
+   * @param assetFile   The AssetFile to convert
    */
-  async count(props) {
-    countGitTagsSchema.parse(props);
-    const gitTags = await this.list({ path: props.path });
-    return gitTags.total;
+  async toAsset(projectId, assetFile) {
+    const assetPath = pathTo.asset(
+      projectId,
+      assetFile.id,
+      assetFile.language,
+      assetFile.extension
+    );
+    const asset = {
+      ...assetFile,
+      absolutePath: assetPath
+    };
+    return asset;
   }
   /**
-   * Type guard for GitTag
+   * Returns the found and supported extension as well as mime type,
+   * otherwise throws an error
    *
-   * @param obj The object to check
+   * @param filePath Path to the file to check
    */
-  isGitTag(obj) {
-    return gitTagSchema.safeParse(obj).success;
+  async getSupportedFileTypeOrThrow(filePath) {
+    const fileSize = (await import_fs_extra3.default.stat(filePath)).size;
+    if (fileSize / 1e3 <= 500) {
+      const fileBuffer = await import_fs_extra3.default.readFile(filePath);
+      if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
+        return {
+          extension: supportedAssetExtensionSchema.Enum.svg,
+          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
+        };
+      }
+    }
+    const { fileTypeFromFile } = await import("file-type");
+    const fileType = await fileTypeFromFile(filePath);
+    const result = supportedAssetTypeSchema.parse({
+      extension: fileType?.ext,
+      mimeType: fileType?.mime
+    });
+    return result;
   }
 };
 
-// src/schema/userSchema.ts
-var import_zod11 = __toESM(require("zod"), 1);
-var UserTypeSchema = import_zod11.default.enum(["local", "cloud"]);
-var baseUserSchema = gitSignatureSchema.extend({
-  userType: UserTypeSchema,
-  language: supportedLanguageSchema
-});
-var localUserSchema = baseUserSchema.extend({
-  userType: import_zod11.default.literal(UserTypeSchema.Enum.local)
-});
-var cloudUserSchema = baseUserSchema.extend({
-  userType: import_zod11.default.literal(UserTypeSchema.Enum.cloud),
-  id: uuidSchema
-});
-var userFileSchema = import_zod11.default.union([localUserSchema, cloudUserSchema]);
-var userSchema = userFileSchema;
-var setUserSchema = userSchema;
+// src/service/CollectionService.ts
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
 
-// src/service/JsonFileService.ts
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var JsonFileService = class extends AbstractCrudService {
-  constructor(options) {
-    super(serviceTypeSchema.Enum.JsonFile, options);
-    this.cache = /* @__PURE__ */ new Map();
+// src/service/GitService.ts
+var import_dugite = require("dugite");
+var import_os3 = require("os");
+var import_p_queue = __toESM(require("p-queue"), 1);
+
+// src/service/GitTagService.ts
+var import_os2 = require("os");
+var GitTagService = class extends AbstractCrudService {
+  constructor(options, git) {
+    super(serviceTypeSchema.Enum.GitTag, options);
+    this.git = git;
   }
   /**
-   * Creates a new file on disk. Fails if path already exists
+   * Creates a new tag
    *
-   * @param data Data to write into the file
-   * @param path Path to write the file to
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---annotate
    */
-  async create(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await import_fs_extra2.default.writeFile(path, string, {
-      flag: "wx",
-      encoding: "utf8"
+  async create(props) {
+    createGitTagSchema.parse(props);
+    const id = uuid();
+    let args = ["tag", "--annotate", id];
+    if (props.hash) {
+      args = [...args, props.hash];
+    }
+    args = [...args, "-m", props.message];
+    await this.git(props.path, args);
+    const tag = await this.read({ path: props.path, id });
+    return tag;
+  }
+  /**
+   * Returns a tag by ID
+   *
+   * Internally uses list() but only returns the tag with matching ID.
+   */
+  async read(props) {
+    readGitTagSchema.parse(props);
+    const tags = await this.list({ path: props.path });
+    const tag = tags.list.find((tag2) => {
+      return tag2.id === props.id;
     });
-    this.cache.set(path, parsedData);
-    return parsedData;
+    if (!tag) {
+      throw new GitError(
+        `Provided tag with UUID "${props.id}" did not match any known tags`
+      );
+    }
+    return tag;
   }
   /**
-   * Reads the content of a file on disk. Fails if path does not exist
+   * Updating a git tag is not supported.
+   * Please delete the old and create a new one
+   *
+   * @see https://git-scm.com/docs/git-tag#_on_re_tagging
+   */
+  async update() {
+    throw new Error(
+      "Updating a git tag is not supported. Please delete the old and create a new one"
+    );
+  }
+  /**
+   * Deletes a tag
+   *
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---delete
+   *
+   * @param path  Path to the repository
+   * @param id    UUID of the tag to delete
+   */
+  async delete(props) {
+    deleteGitTagSchema.parse(props);
+    const args = ["tag", "--delete", props.id];
+    await this.git(props.path, args);
+  }
+  /**
+   * Gets all local tags or filter them by pattern
+   *
+   * They are sorted by authordate of the commit, not the timestamp the tag is created.
+   * This ensures tags are sorted correctly in the timeline of their commits.
    *
-   * @param path Path to read the file from
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
+   * @see https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---list
    */
-  async read(path, schema) {
-    if (this.cache.has(path)) {
-      return this.cache.get(path);
-    }
-    const data = await import_fs_extra2.default.readFile(path, {
-      flag: "r",
-      encoding: "utf8"
+  async list(props) {
+    listGitTagsSchema.parse(props);
+    let args = ["tag", "--list"];
+    args = [
+      ...args,
+      "--sort=-*authordate",
+      "--format=%(refname:short)|%(subject)|%(*authorname)|%(*authoremail)|%(*authordate:unix)"
+    ];
+    const result = await this.git(props.path, args);
+    const noEmptyLinesArr = result.stdout.split(import_os2.EOL).filter((line) => {
+      return line.trim() !== "";
     });
-    const json = this.deserialize(data);
-    const parsedData = schema.parse(json);
-    this.cache.set(path, parsedData);
-    return parsedData;
+    const lineObjArr = noEmptyLinesArr.map((line) => {
+      const lineArray = line.split("|");
+      return {
+        id: lineArray[0],
+        message: lineArray[1],
+        author: {
+          name: lineArray[2],
+          email: lineArray[3]
+        },
+        timestamp: parseInt(lineArray[4])
+      };
+    });
+    const gitTags = lineObjArr.filter(this.isGitTag.bind(this));
+    return {
+      total: gitTags.length,
+      limit: 0,
+      offset: 0,
+      list: gitTags
+    };
   }
   /**
-   * Overwrites an existing file on disk
+   * Returns the total number of tags inside given repository
    *
-   * @todo Check how to error out if the file does not exist already
+   * Internally uses list(), so do not use count()
+   * in conjuncion with it to avoid multiple git calls.
    *
-   * @param data Data to write into the file
-   * @param path Path to the file to overwrite
-   * @param schema Schema of the file to validate against
-   * @returns Validated content of the file from disk
+   * @param path Path to the repository
    */
-  async update(data, path, schema) {
-    const parsedData = schema.parse(data);
-    const string = this.serialize(parsedData);
-    await import_fs_extra2.default.writeFile(path, string, {
-      flag: "w",
-      encoding: "utf8"
-    });
-    this.cache.set(path, parsedData);
-    return parsedData;
-  }
-  serialize(data) {
-    return JSON.stringify(data, null, this.options.file.json.indentation);
+  async count(props) {
+    countGitTagsSchema.parse(props);
+    const gitTags = await this.list({ path: props.path });
+    return gitTags.total;
   }
-  deserialize(data) {
-    return JSON.parse(data);
+  /**
+   * Type guard for GitTag
+   *
+   * @param obj The object to check
+   */
+  isGitTag(obj) {
+    return gitTagSchema.safeParse(obj).success;
   }
 };
 
@@ -1589,10 +1848,7 @@ var UserService = class {
    */
   async get() {
     try {
-      return await this.jsonFileService.read(
-        pathTo.userFile,
-        userFileSchema
-      );
+      return await this.jsonFileService.read(pathTo.userFile, userFileSchema);
     } catch (error) {
       return void 0;
     }
@@ -1860,507 +2116,277 @@ var GitService2 = class {
   /**
    * Download objects and refs from remote `origin`
    *
-   * @see https://www.git-scm.com/docs/git-fetch
-   *
-   * @param path Path to the repository
-   */
-  async fetch(path) {
-    const args = ["fetch"];
-    await this.git(path, args);
-  }
-  /**
-   * Fetch from and integrate (rebase or merge) with a local branch
-   *
-   * @see https://git-scm.com/docs/git-pull
-   *
-   * @param path Path to the repository
-   */
-  async pull(path) {
-    const args = ["pull"];
-    await this.git(path, args);
-  }
-  /**
-   * Update remote refs along with associated objects to remote `origin`
-   *
-   * @see https://git-scm.com/docs/git-push
-   *
-   * @param path Path to the repository
-   */
-  async push(path, options) {
-    let args = ["push", "origin"];
-    if (options?.all === true) {
-      args = [...args, "--all"];
-    }
-    if (options?.force === true) {
-      args = [...args, "--force"];
-    }
-    await this.git(path, args);
-  }
-  /**
-   * Record changes to the repository
-   *
-   * @see https://git-scm.com/docs/git-commit
-   *
-   * @param path    Path to the repository
-   * @param message A message that describes the changes
-   */
-  async commit(path, message) {
-    const user = await this.userService.get();
-    if (!user) {
-      throw new NoCurrentUserError();
-    }
-    const args = [
-      "commit",
-      `--message=${message}`,
-      `--author=${user.name} <${user.email}>`
-    ];
-    await this.git(path, args);
-  }
-  /**
-   * Gets local commit history
-   *
-   * @see https://git-scm.com/docs/git-log
-   *
-   * @todo Check if there is a need to trim the git commit message of chars
-   * @todo Use this method in a service. Decide if we need a HistoryService for example
-   *
-   * @param path    Path to the repository
-   * @param options Options specific to the log operation
-   */
-  async log(path, options) {
-    let args = ["log"];
-    if (options?.between?.from) {
-      args = [
-        ...args,
-        `${options.between.from}..${options.between.to || "HEAD"}`
-      ];
-    }
-    if (options?.limit) {
-      args = [...args, `--max-count=${options.limit}`];
-    }
-    const result = await this.git(path, [
-      ...args,
-      "--format=%H|%s|%an|%ae|%at|%D"
-    ]);
-    const noEmptyLinesArr = result.stdout.split(import_os3.EOL).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]
-        },
-        timestamp: parseInt(lineArray[4]),
-        tag: this.refNameToTagName(lineArray[5])
-      };
-    });
-    return lineObjArr.filter(this.isGitCommit.bind(this));
-  }
-  refNameToTagName(refName) {
-    const tagName = refName.replace("tag: ", "").trim();
-    if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
-      return null;
-    }
-    return tagName;
-  }
-  /**
-   * Returns a timestamp of given files creation
-   *
-   * Git only returns the timestamp the file was added,
-   * which could be different from the file being created.
-   * But since file operations will always be committed
-   * immediately, this is practically the same.
-   *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
-   */
-  async getFileCreatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--diff-filter=A",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns a timestamp of the files last modification
-   *
-   * @param path Path to the repository
-   * @param file File to get timestamp from
-   */
-  async getFileLastUpdatedTimestamp(path, file) {
-    const result = await this.git(path, [
-      "log",
-      "--follow",
-      "--format=%at",
-      "--max-count=1",
-      "--",
-      file
-    ]);
-    return parseInt(result.stdout);
-  }
-  /**
-   * Returns created and updated timestamps from given file
-   *
-   * @param path Path to the project
-   * @param file Path to the file
-   */
-  async getFileCreatedUpdatedMeta(path, file) {
-    const meta = await Promise.all([
-      this.getFileCreatedTimestamp(path, file),
-      this.getFileLastUpdatedTimestamp(path, file)
-    ]);
-    return {
-      created: meta[0],
-      updated: meta[1]
-    };
-  }
-  /**
-   * Reads the currently used version of Git
-   *
-   * This can help debugging
-   */
-  async updateVersion() {
-    const result = await this.git("", ["--version"]);
-    this.version = result.stdout.replace("git version", "").trim();
-  }
-  /**
-   * Reads the path to the executable of Git that is used
-   *
-   * This can help debugging, since dugite is shipping their own executable
-   * but in some cases resolves another executable
-   * @see https://github.com/desktop/dugite/blob/main/lib/git-environment.ts
+   * @see https://www.git-scm.com/docs/git-fetch
+   *
+   * @param path Path to the repository
    */
-  async updateGitPath() {
-    const result = await this.git("", ["--exec-path"]);
-    this.gitPath = result.stdout.trim();
+  async fetch(path) {
+    const args = ["fetch"];
+    await this.git(path, args);
   }
   /**
-   * A reference is used in Git to specify branches and tags.
-   * This method checks if given name matches the required format
+   * Fetch from and integrate (rebase or merge) with a local branch
    *
-   * @see https://git-scm.com/docs/git-check-ref-format
+   * @see https://git-scm.com/docs/git-pull
    *
    * @param path Path to the repository
-   * @param name Name to check
    */
-  async checkBranchOrTagName(path, name) {
-    await this.git(path, ["check-ref-format", "--allow-onelevel", name]);
+  async pull(path) {
+    const args = ["pull"];
+    await this.git(path, args);
   }
   /**
-   * Installs LFS support and starts tracking
-   * all files inside the lfs folder
+   * Update remote refs along with associated objects to remote `origin`
+   *
+   * @see https://git-scm.com/docs/git-push
    *
    * @param path Path to the repository
    */
-  async installLfs(path) {
-    await this.git(path, ["lfs", "install"]);
-    await this.git(path, ["lfs", "track", "lfs/*"]);
+  async push(path, options) {
+    let args = ["push", "origin"];
+    if (options?.all === true) {
+      args = [...args, "--all"];
+    }
+    if (options?.force === true) {
+      args = [...args, "--force"];
+    }
+    await this.git(path, args);
   }
   /**
-   * Sets the git config of given local repository from ElekIoCoreOptions
+   * Record changes to the repository
    *
-   * @param path Path to the repository
+   * @see https://git-scm.com/docs/git-commit
+   *
+   * @param path    Path to the repository
+   * @param message A message that describes the changes
    */
-  async setLocalConfig(path) {
+  async commit(path, message) {
     const user = await this.userService.get();
     if (!user) {
       throw new NoCurrentUserError();
     }
-    const userNameArgs = ["config", "--local", "user.name", user.name];
-    const userEmailArgs = ["config", "--local", "user.email", user.email];
-    const autoSetupRemoteArgs = [
-      "config",
-      "--local",
-      "push.autoSetupRemote",
-      "true"
+    const args = [
+      "commit",
+      `--message=${message}`,
+      `--author=${user.name} <${user.email}>`
     ];
-    await this.git(path, userNameArgs);
-    await this.git(path, userEmailArgs);
-    await this.git(path, autoSetupRemoteArgs);
+    await this.git(path, args);
   }
   /**
-   * Type guard for GitCommit
+   * Gets local commit history
    *
-   * @param obj The object to check
-   */
-  isGitCommit(obj) {
-    return gitCommitSchema.safeParse(obj).success;
-  }
-  /**
-   * Wraps the execution of any git command
-   * to use a FIFO queue for sequential processing
+   * @see https://git-scm.com/docs/git-log
    *
-   * @param path Path to the repository
-   * @param args Arguments to append after the `git` command
+   * @todo Check if there is a need to trim the git commit message of chars
+   * @todo Use this method in a service. Decide if we need a HistoryService for example
+   *
+   * @param path    Path to the repository
+   * @param options Options specific to the log operation
    */
-  async git(path, args) {
-    const result = await this.queue.add(
-      () => import_dugite.GitProcess.exec(args, path, {
-        env: {
-          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
-          // @see https://github.com/git-lfs/git-lfs/issues/5749
-          GIT_CLONE_PROTECTION_ACTIVE: "false"
-        }
-      })
-    );
-    if (!result) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed to return a result`
-      );
+  async log(path, options) {
+    let args = ["log"];
+    if (options?.between?.from) {
+      args = [
+        ...args,
+        `${options.between.from}..${options.between.to || "HEAD"}`
+      ];
     }
-    if (result.exitCode !== 0) {
-      throw new GitError(
-        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
-          " "
-        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
-      );
+    if (options?.limit) {
+      args = [...args, `--max-count=${options.limit}`];
     }
-    return result;
-  }
-};
-
-// src/service/AssetService.ts
-var AssetService = class extends AbstractCrudService {
-  constructor(options, jsonFileService, gitService) {
-    super(serviceTypeSchema.Enum.Asset, options);
-    this.jsonFileService = jsonFileService;
-    this.gitService = gitService;
+    const result = await this.git(path, [
+      ...args,
+      "--format=%H|%s|%an|%ae|%at|%D"
+    ]);
+    const noEmptyLinesArr = result.stdout.split(import_os3.EOL).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]
+        },
+        timestamp: parseInt(lineArray[4]),
+        tag: this.refNameToTagName(lineArray[5])
+      };
+    });
+    return lineObjArr.filter(this.isGitCommit.bind(this));
   }
-  /**
-   * Creates a new Asset
-   */
-  async create(props) {
-    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 assetPath = pathTo.asset(
-      props.projectId,
-      id,
-      props.language,
-      fileType.extension
-    );
-    const assetFilePath = pathTo.assetFile(
-      props.projectId,
-      id,
-      props.language
-    );
-    const assetFile = {
-      ...props,
-      objectType: "asset",
-      id,
-      created: currentTimestamp(),
-      updated: null,
-      extension: fileType.extension,
-      mimeType: fileType.mimeType,
-      size
-    };
-    try {
-      await import_fs_extra3.default.copyFile(props.filePath, assetPath);
-      await this.jsonFileService.create(
-        assetFile,
-        assetFilePath,
-        assetFileSchema
-      );
-    } catch (error) {
-      await this.delete({ ...assetFile, projectId: props.projectId });
-      throw error;
+  refNameToTagName(refName) {
+    const tagName = refName.replace("tag: ", "").trim();
+    if (tagName === "" || uuidSchema.safeParse(tagName).success === false) {
+      return null;
     }
-    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.create);
-    return this.toAsset(props.projectId, assetFile);
-  }
-  /**
-   * Returns an Asset by ID and language
-   */
-  async read(props) {
-    readAssetSchema.parse(props);
-    const assetFile = await this.jsonFileService.read(
-      pathTo.assetFile(props.projectId, props.id, props.language),
-      assetFileSchema
-    );
-    return this.toAsset(props.projectId, assetFile);
+    return tagName;
   }
   /**
-   * Updates given Asset
+   * Returns a timestamp of given files creation
    *
-   * Use the optional "newFilePath" prop to update the Asset itself
-   */
-  async update(props) {
-    updateAssetSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const assetFilePath = pathTo.assetFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    const prevAssetFile = await this.read(props);
-    const assetFile = {
-      ...prevAssetFile,
-      ...props,
-      updated: currentTimestamp()
-    };
-    if (props.newFilePath) {
-      const fileType = await this.getSupportedFileTypeOrThrow(
-        props.newFilePath
-      );
-      const size = await this.getAssetSize(props.newFilePath);
-      const prevAssetPath = pathTo.asset(
-        props.projectId,
-        props.id,
-        props.language,
-        prevAssetFile.extension
-      );
-      const assetPath = pathTo.asset(
-        props.projectId,
-        props.id,
-        props.language,
-        fileType.extension
-      );
-      await import_fs_extra3.default.remove(prevAssetPath);
-      await import_fs_extra3.default.copyFile(props.newFilePath, assetPath);
-      assetFile.extension = fileType.extension;
-      assetFile.mimeType = fileType.mimeType;
-      assetFile.size = size;
-    }
-    await this.jsonFileService.update(
-      assetFile,
-      assetFilePath,
-      assetFileSchema
-    );
-    await this.gitService.add(projectPath, [assetFilePath]);
-    await this.gitService.commit(projectPath, this.gitMessage.update);
-    return this.toAsset(props.projectId, assetFile);
+   * Git only returns the timestamp the file was added,
+   * which could be different from the file being created.
+   * But since file operations will always be committed
+   * immediately, this is practically the same.
+   *
+   * @param path Path to the repository
+   * @param file File to get timestamp from
+   */
+  async getFileCreatedTimestamp(path, file) {
+    const result = await this.git(path, [
+      "log",
+      "--diff-filter=A",
+      "--follow",
+      "--format=%at",
+      "--max-count=1",
+      "--",
+      file
+    ]);
+    return parseInt(result.stdout);
   }
   /**
-   * Deletes given Asset
+   * Returns a timestamp of the files last modification
+   *
+   * @param path Path to the repository
+   * @param file File to get timestamp from
    */
-  async delete(props) {
-    deleteAssetSchema.parse(props);
-    const projectPath = pathTo.project(props.projectId);
-    const assetFilePath = pathTo.assetFile(
-      props.projectId,
-      props.id,
-      props.language
-    );
-    const assetPath = pathTo.asset(
-      props.projectId,
-      props.id,
-      props.language,
-      props.extension
-    );
-    await import_fs_extra3.default.remove(assetPath);
-    await import_fs_extra3.default.remove(assetFilePath);
-    await this.gitService.add(projectPath, [assetFilePath, assetPath]);
-    await this.gitService.commit(projectPath, this.gitMessage.delete);
+  async getFileLastUpdatedTimestamp(path, file) {
+    const result = await this.git(path, [
+      "log",
+      "--follow",
+      "--format=%at",
+      "--max-count=1",
+      "--",
+      file
+    ]);
+    return parseInt(result.stdout);
   }
-  async list(props) {
-    listAssetsSchema.parse(props);
-    const offset = props.offset || 0;
-    const limit = props.limit || 15;
-    const assetReferences = await this.listReferences(
-      objectTypeSchema.Enum.asset,
-      props.projectId
-    );
-    const partialAssetReferences = assetReferences.slice(offset, limit);
-    const assets = await returnResolved(
-      partialAssetReferences.map((assetReference) => {
-        if (!assetReference.language) {
-          throw new RequiredParameterMissingError("language");
-        }
-        return this.read({
-          projectId: props.projectId,
-          id: assetReference.id,
-          language: assetReference.language
-        });
-      })
-    );
+  /**
+   * Returns created and updated timestamps from given file
+   *
+   * @param path Path to the project
+   * @param file Path to the file
+   */
+  async getFileCreatedUpdatedMeta(path, file) {
+    const meta = await Promise.all([
+      this.getFileCreatedTimestamp(path, file),
+      this.getFileLastUpdatedTimestamp(path, file)
+    ]);
     return {
-      total: assetReferences.length,
-      limit,
-      offset,
-      list: assets
+      created: meta[0],
+      updated: meta[1]
     };
   }
-  async count(props) {
-    countAssetsSchema.parse(props);
-    const count = (await this.listReferences(objectTypeSchema.Enum.asset, props.projectId)).length;
-    return count;
+  /**
+   * Reads the currently used version of Git
+   *
+   * This can help debugging
+   */
+  async updateVersion() {
+    const result = await this.git("", ["--version"]);
+    this.version = result.stdout.replace("git version", "").trim();
   }
   /**
-   * Checks if given object is of type Asset
+   * Reads the path to the executable of Git that is used
+   *
+   * This can help debugging, since dugite is shipping their own executable
+   * but in some cases resolves another executable
+   * @see https://github.com/desktop/dugite/blob/main/lib/git-environment.ts
    */
-  isAsset(obj) {
-    return assetSchema.safeParse(obj).success;
+  async updateGitPath() {
+    const result = await this.git("", ["--exec-path"]);
+    this.gitPath = result.stdout.trim();
   }
   /**
-   * Returns the size of an Asset in bytes
+   * A reference is used in Git to specify branches and tags.
+   * This method checks if given name matches the required format
    *
-   * @param path Path of the Asset to get the size from
+   * @see https://git-scm.com/docs/git-check-ref-format
+   *
+   * @param path Path to the repository
+   * @param name Name to check
    */
-  async getAssetSize(path) {
-    return (await import_fs_extra3.default.stat(path)).size;
+  async checkBranchOrTagName(path, name) {
+    await this.git(path, ["check-ref-format", "--allow-onelevel", name]);
   }
   /**
-   * Creates an Asset from given AssetFile
+   * Installs LFS support and starts tracking
+   * all files inside the lfs folder
    *
-   * @param projectId   The project's ID
-   * @param assetFile   The AssetFile to convert
+   * @param path Path to the repository
    */
-  async toAsset(projectId, assetFile) {
-    const assetPath = pathTo.asset(
-      projectId,
-      assetFile.id,
-      assetFile.language,
-      assetFile.extension
-    );
-    const asset = {
-      ...assetFile,
-      absolutePath: assetPath
-    };
-    return asset;
+  async installLfs(path) {
+    await this.git(path, ["lfs", "install"]);
+    await this.git(path, ["lfs", "track", "lfs/*"]);
   }
   /**
-   * Returns the found and supported extension as well as mime type,
-   * otherwise throws an error
+   * Sets the git config of given local repository from ElekIoCoreOptions
    *
-   * @param filePath Path to the file to check
+   * @param path Path to the repository
    */
-  async getSupportedFileTypeOrThrow(filePath) {
-    const fileSize = (await import_fs_extra3.default.stat(filePath)).size;
-    if (fileSize / 1e3 <= 500) {
-      const fileBuffer = await import_fs_extra3.default.readFile(filePath);
-      if ((0, import_is_svg.default)(fileBuffer.toString()) === true) {
-        return {
-          extension: supportedAssetExtensionSchema.Enum.svg,
-          mimeType: supportedAssetMimeTypeSchema.Enum["image/svg+xml"]
-        };
-      }
+  async setLocalConfig(path) {
+    const user = await this.userService.get();
+    if (!user) {
+      throw new NoCurrentUserError();
+    }
+    const userNameArgs = ["config", "--local", "user.name", user.name];
+    const userEmailArgs = ["config", "--local", "user.email", user.email];
+    const autoSetupRemoteArgs = [
+      "config",
+      "--local",
+      "push.autoSetupRemote",
+      "true"
+    ];
+    await this.git(path, userNameArgs);
+    await this.git(path, userEmailArgs);
+    await this.git(path, autoSetupRemoteArgs);
+  }
+  /**
+   * Type guard for GitCommit
+   *
+   * @param obj The object to check
+   */
+  isGitCommit(obj) {
+    return gitCommitSchema.safeParse(obj).success;
+  }
+  /**
+   * Wraps the execution of any git command
+   * to use a FIFO queue for sequential processing
+   *
+   * @param path Path to the repository
+   * @param args Arguments to append after the `git` command
+   */
+  async git(path, args) {
+    const result = await this.queue.add(
+      () => import_dugite.GitProcess.exec(args, path, {
+        env: {
+          // @todo Nasty stuff - remove after update to dugite with git > v2.45.2 once available
+          // @see https://github.com/git-lfs/git-lfs/issues/5749
+          GIT_CLONE_PROTECTION_ACTIVE: "false"
+        }
+      })
+    );
+    if (!result) {
+      throw new GitError(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
+          " "
+        )}" failed to return a result`
+      );
+    }
+    if (result.exitCode !== 0) {
+      throw new GitError(
+        `Git ${this.version} (${this.gitPath}) command "git ${args.join(
+          " "
+        )}" failed with exit code "${result.exitCode}" and message "${result.stderr}"`
+      );
     }
-    const { fileTypeFromFile } = await import("file-type");
-    const fileType = await fileTypeFromFile(filePath);
-    const result = supportedAssetTypeSchema.parse({
-      extension: fileType?.ext,
-      mimeType: fileType?.mime
-    });
     return result;
   }
 };
 
 // src/service/CollectionService.ts
-var import_fs_extra4 = __toESM(require("fs-extra"), 1);
 var CollectionService = class extends AbstractCrudService {
   constructor(options, jsonFileService, gitService) {
     super(serviceTypeSchema.Enum.Collection, options);
@@ -2421,10 +2447,7 @@ var CollectionService = class extends AbstractCrudService {
   async update(props) {
     updateCollectionSchema.parse(props);
     const projectPath = pathTo.project(props.projectId);
-    const collectionFilePath = pathTo.collectionFile(
-      props.projectId,
-      props.id
-    );
+    const collectionFilePath = pathTo.collectionFile(props.projectId, props.id);
     const prevCollectionFile = await this.read(props);
     const collectionFile = {
       ...prevCollectionFile,
@@ -2798,16 +2821,6 @@ var import_fs_extra6 = __toESM(require("fs-extra"), 1);
 var import_os4 = __toESM(require("os"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_semver = __toESM(require("semver"), 1);
-
-// src/error/ProjectUpgradeError.ts
-var ProjectUpgradeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProjectUpgradeError";
-  }
-};
-
-// src/service/ProjectService.ts
 var ProjectService = class extends AbstractCrudService {
   constructor(options, jsonFileService, userService, gitService, assetService, collectionService, entryService) {
     super(serviceTypeSchema.Enum.Project, options);
@@ -3190,36 +3203,7 @@ var ProjectService = class extends AbstractCrudService {
   }
 };
 
-// src/schema/coreSchema.ts
-var import_zod12 = require("zod");
-var elekIoCoreOptionsSchema = import_zod12.z.object({
-  /**
-   * The environment elek.io Core is currently running in
-   */
-  environment: environmentSchema,
-  /**
-   * The current version of elek.io Core
-   */
-  version: versionSchema,
-  file: import_zod12.z.object({
-    json: import_zod12.z.object({
-      /**
-       * If set, adds indentation with spaces (number) or escape character (string)
-       * and line break characters to saved JSON files on disk, to make them easier to read.
-       * Defaults to 2 spaces of indentation.
-       */
-      indentation: import_zod12.z.union([import_zod12.z.number(), import_zod12.z.string()])
-    })
-  })
-});
-var constructorElekIoCoreSchema = elekIoCoreOptionsSchema.omit({
-  version: true
-}).partial({
-  environment: true,
-  file: true
-}).optional();
-
-// src/index.ts
+// src/index.node.ts
 var ElekIoCore = class {
   // private readonly sharedValueService: SharedValueService;
   constructor(props) {
@@ -3280,7 +3264,7 @@ var ElekIoCore = class {
    * Utility / helper functions
    */
   get util() {
-    return util_exports;
+    return node_exports;
   }
   /**
    * Exposes git functions
@@ -3359,6 +3343,7 @@ var ElekIoCore = class {
   createGitTagSchema,
   createProjectSchema,
   currentBranchProjectSchema,
+  currentTimestamp,
   dateValueDefinitionSchema,
   datetimeValueDefinitionSchema,
   deleteAssetSchema,
@@ -3422,6 +3407,7 @@ var ElekIoCore = class {
   serviceTypeSchema,
   setRemoteOriginUrlProjectSchema,
   setUserSchema,
+  slug,
   stringValueDefinitionSchema,
   supportedAssetExtensionSchema,
   supportedAssetMimeTypeSchema,
@@ -3447,6 +3433,7 @@ var ElekIoCore = class {
   urlValueDefinitionSchema,
   userFileSchema,
   userSchema,
+  uuid,
   uuidSchema,
   valueContentReferenceBase,
   valueContentReferenceSchema,
@@ -3458,4 +3445,4 @@ var ElekIoCore = class {
   valueSchema,
   versionSchema
 });
-//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.node.cjs.map