@elek-io/core 0.14.4 → 0.15.1

package/dist/browser/index.browser.js

@@ -2,7 +2,7 @@
 import { z as z4 } from "@hono/zod-openapi";
 
 // src/schema/baseSchema.ts
-import z from "zod";
+import { z } from "@hono/zod-openapi";
 var supportedLanguageSchema = z.enum([
   /**
    * Bulgarian
@@ -89,7 +89,7 @@ function translatableArrayOf(schema) {
 }
 
 // src/schema/fileSchema.ts
-import z2 from "zod";
+import { z as z2 } from "@hono/zod-openapi";
 var baseFileSchema = z2.object({
   /**
    * The object type of the file
@@ -116,7 +116,7 @@ var fileReferenceSchema = z2.object({
 });
 
 // src/schema/gitSchema.ts
-import { z as z3 } from "zod";
+import { z as z3 } from "@hono/zod-openapi";
 var gitSignatureSchema = z3.object({
   name: z3.string(),
   email: z3.string().email()
@@ -305,7 +305,7 @@ import { z as z8 } from "@hono/zod-openapi";
 import { z as z6 } from "@hono/zod-openapi";
 
 // src/schema/valueSchema.ts
-import z5 from "zod";
+import { z as z5 } from "@hono/zod-openapi";
 var ValueTypeSchema = z5.enum([
   "string",
   "number",
@@ -402,7 +402,7 @@ var countEntriesSchema = z6.object({
 });
 
 // src/schema/fieldSchema.ts
-import { z as z7 } from "zod";
+import { z as z7 } from "@hono/zod-openapi";
 var FieldTypeSchema = z7.enum([
   // String Values
   "text",
@@ -429,7 +429,7 @@ var FieldWidthSchema = z7.enum(["12", "6", "4", "3"]);
 var FieldDefinitionBaseSchema = z7.object({
   id: uuidSchema.readonly(),
   label: translatableStringSchema,
-  description: translatableStringSchema,
+  description: translatableStringSchema.nullable(),
   isRequired: z7.boolean(),
   isDisabled: z7.boolean(),
   isUnique: z7.boolean(),
@@ -551,104 +551,6 @@ var fieldDefinitionSchema = z7.union([
   entryFieldDefinitionSchema
   // sharedValueDefinitionSchema,
 ]);
-function getValueContentSchemaFromFieldDefinition(fieldDefinition) {
-  switch (fieldDefinition.valueType) {
-    case ValueTypeSchema.enum.boolean:
-      return getBooleanValueContentSchema();
-    case ValueTypeSchema.enum.number:
-      return getNumberValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.enum.string:
-      return getStringValueContentSchema(fieldDefinition);
-    case ValueTypeSchema.enum.reference:
-      return getReferenceValueContentSchema(fieldDefinition);
-    default:
-      throw new Error(
-        // @ts-expect-error
-        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
-      );
-  }
-}
-function getBooleanValueContentSchema() {
-  return z7.boolean();
-}
-function getNumberValueContentSchema(definition) {
-  let schema = z7.number();
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema;
-}
-function getStringValueContentSchema(definition) {
-  let schema = null;
-  switch (definition.fieldType) {
-    case FieldTypeSchema.enum.email:
-      schema = z7.email();
-      break;
-    case FieldTypeSchema.enum.url:
-      schema = z7.url();
-      break;
-    case FieldTypeSchema.enum.ipv4:
-      schema = z7.ipv4();
-      break;
-    case FieldTypeSchema.enum.date:
-      schema = z7.iso.date();
-      break;
-    case FieldTypeSchema.enum.time:
-      schema = z7.iso.time();
-      break;
-    case FieldTypeSchema.enum.datetime:
-      schema = z7.iso.datetime();
-      break;
-    case FieldTypeSchema.enum.telephone:
-      schema = z7.e164();
-      break;
-    case FieldTypeSchema.enum.text:
-    case FieldTypeSchema.enum.textarea:
-      schema = z7.string().trim();
-      break;
-  }
-  if ("min" in definition && definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if ("max" in definition && definition.max) {
-    schema = schema.max(definition.max);
-  }
-  if (definition.isRequired === false) {
-    return schema.nullable();
-  }
-  return schema.min(1, "shared.stringValueRequired");
-}
-function getReferenceValueContentSchema(definition) {
-  let schema;
-  switch (definition.fieldType) {
-    case FieldTypeSchema.enum.asset:
-      {
-        schema = z7.array(valueContentReferenceToAssetSchema);
-      }
-      break;
-    case FieldTypeSchema.enum.entry:
-      {
-        schema = z7.array(valueContentReferenceToEntrySchema);
-      }
-      break;
-  }
-  if (definition.isRequired) {
-    schema = schema.min(1, "shared.referenceRequired");
-  }
-  if (definition.min) {
-    schema = schema.min(definition.min);
-  }
-  if (definition.max) {
-    schema = schema.max(definition.max);
-  }
-  return schema;
-}
 
 // src/schema/collectionSchema.ts
 var collectionFileSchema = baseFileSchema.extend({
@@ -703,7 +605,7 @@ var countCollectionsSchema = z8.object({
 });
 
 // src/schema/coreSchema.ts
-import { z as z9 } from "zod";
+import { z as z9 } from "@hono/zod-openapi";
 var elekIoCoreOptionsSchema = z9.object({
   log: z9.object({
     /**
@@ -854,9 +756,172 @@ var searchProjectSchema = z10.object({
   type: z10.array(objectTypeSchema).optional()
 });
 
+// src/schema/schemaFromFieldDefinition.ts
+import { z as z11 } from "@hono/zod-openapi";
+function getBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.boolean();
+}
+function getNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = z11.number();
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema;
+}
+function getStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema = null;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.email:
+      schema = z11.email();
+      break;
+    case FieldTypeSchema.enum.url:
+      schema = z11.url();
+      break;
+    case FieldTypeSchema.enum.ipv4:
+      schema = z11.ipv4();
+      break;
+    case FieldTypeSchema.enum.date:
+      schema = z11.iso.date();
+      break;
+    case FieldTypeSchema.enum.time:
+      schema = z11.iso.time();
+      break;
+    case FieldTypeSchema.enum.datetime:
+      schema = z11.iso.datetime();
+      break;
+    case FieldTypeSchema.enum.telephone:
+      schema = z11.e164();
+      break;
+    case FieldTypeSchema.enum.text:
+    case FieldTypeSchema.enum.textarea:
+      schema = z11.string().trim();
+      break;
+  }
+  if ("min" in fieldDefinition && fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if ("max" in fieldDefinition && fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  if (fieldDefinition.isRequired === false) {
+    return schema.nullable();
+  }
+  return schema.min(1, "shared.stringValueRequired");
+}
+function getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  let schema;
+  switch (fieldDefinition.fieldType) {
+    case FieldTypeSchema.enum.asset:
+      {
+        schema = z11.array(valueContentReferenceToAssetSchema);
+      }
+      break;
+    case FieldTypeSchema.enum.entry:
+      {
+        schema = z11.array(valueContentReferenceToEntrySchema);
+      }
+      break;
+  }
+  if (fieldDefinition.isRequired) {
+    schema = schema.min(1, "shared.referenceRequired");
+  }
+  if (fieldDefinition.min) {
+    schema = schema.min(fieldDefinition.min);
+  }
+  if (fieldDefinition.max) {
+    schema = schema.max(fieldDefinition.max);
+  }
+  return schema;
+}
+function getTranslatableStringValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getStringValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableNumberValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getNumberValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getTranslatableBooleanValueContentSchemaFromFieldDefinition() {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getBooleanValueContentSchemaFromFieldDefinition()
+  );
+}
+function getTranslatableReferenceValueContentSchemaFromFieldDefinition(fieldDefinition) {
+  return z11.partialRecord(
+    supportedLanguageSchema,
+    getReferenceValueContentSchemaFromFieldDefinition(fieldDefinition)
+  );
+}
+function getValueSchemaFromFieldDefinition(fieldDefinition) {
+  switch (fieldDefinition.valueType) {
+    case ValueTypeSchema.enum.boolean:
+      return directBooleanValueSchema.extend({
+        content: getTranslatableBooleanValueContentSchemaFromFieldDefinition()
+      });
+    case ValueTypeSchema.enum.number:
+      return directNumberValueSchema.extend({
+        content: getTranslatableNumberValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.string:
+      return directStringValueSchema.extend({
+        content: getTranslatableStringValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    case ValueTypeSchema.enum.reference:
+      return referencedValueSchema.extend({
+        content: getTranslatableReferenceValueContentSchemaFromFieldDefinition(
+          fieldDefinition
+        )
+      });
+    default:
+      throw new Error(
+        // @ts-expect-error Code cannot be reached, but if we add a new ValueType and forget to update this function, we want to be notified about it
+        `Error generating schema for unsupported ValueType "${fieldDefinition.valueType}"`
+      );
+  }
+}
+function getCreateEntrySchemaFromFieldDefinitions(fieldDefinitions) {
+  const valueSchemas = fieldDefinitions.map((fieldDefinition) => {
+    return getValueSchemaFromFieldDefinition(fieldDefinition);
+  });
+  return z11.object({
+    ...createEntrySchema.shape,
+    values: z11.tuple(
+      valueSchemas
+      // At least one element is required in a tuple
+    )
+  });
+}
+function getUpdateEntrySchemaFromFieldDefinitions(fieldDefinitions) {
+  const valueSchemas = fieldDefinitions.map((fieldDefinition) => {
+    return getValueSchemaFromFieldDefinition(fieldDefinition);
+  });
+  return z11.object({
+    ...updateEntrySchema.shape,
+    values: z11.tuple(
+      valueSchemas
+      // At least one element is required in a tuple
+    )
+  });
+}
+
 // src/schema/serviceSchema.ts
-import { z as z11 } from "zod";
-var serviceTypeSchema = z11.enum([
+import { z as z12 } from "@hono/zod-openapi";
+var serviceTypeSchema = z12.enum([
   "Git",
   "GitTag",
   "User",
@@ -869,17 +934,17 @@ var serviceTypeSchema = z11.enum([
   "Value"
 ]);
 function paginatedListOf(schema) {
-  return z11.object({
-    total: z11.number(),
-    limit: z11.number(),
-    offset: z11.number(),
-    list: z11.array(schema)
+  return z12.object({
+    total: z12.number(),
+    limit: z12.number(),
+    offset: z12.number(),
+    list: z12.array(schema)
   });
 }
-var listSchema = z11.object({
+var listSchema = z12.object({
   projectId: uuidSchema,
-  limit: z11.number().optional(),
-  offset: z11.number().optional()
+  limit: z12.number().optional(),
+  offset: z12.number().optional()
 });
 var listCollectionsSchema = listSchema;
 var listEntriesSchema = listSchema.extend({
@@ -889,35 +954,35 @@ var listAssetsSchema = listSchema;
 var listProjectsSchema = listSchema.omit({
   projectId: true
 });
-var listGitTagsSchema = z11.object({
-  path: z11.string()
+var listGitTagsSchema = z12.object({
+  path: z12.string()
 });
 
 // src/schema/userSchema.ts
-import z12 from "zod";
-var UserTypeSchema = z12.enum(["local", "cloud"]);
+import { z as z13 } from "@hono/zod-openapi";
+var UserTypeSchema = z13.enum(["local", "cloud"]);
 var baseUserSchema = gitSignatureSchema.extend({
   userType: UserTypeSchema,
   language: supportedLanguageSchema,
-  localApi: z12.object({
+  localApi: z13.object({
     /**
      * If set to true the local API is started whenever Core is initialized
      */
-    isEnabled: z12.boolean(),
+    isEnabled: z13.boolean(),
     /**
      * The port the local API uses
      */
-    port: z12.number()
+    port: z13.number()
   })
 });
 var localUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.enum.local)
+  userType: z13.literal(UserTypeSchema.enum.local)
 });
 var cloudUserSchema = baseUserSchema.extend({
-  userType: z12.literal(UserTypeSchema.enum.cloud),
+  userType: z13.literal(UserTypeSchema.enum.cloud),
   id: uuidSchema
 });
-var userFileSchema = z12.union([localUserSchema, cloudUserSchema]);
+var userFileSchema = z13.union([localUserSchema, cloudUserSchema]);
 var userSchema = userFileSchema;
 var setUserSchema = userSchema;
 
@@ -994,8 +1059,10 @@ export {
   fieldDefinitionSchema,
   fileReferenceSchema,
   getChangesProjectSchema,
+  getCreateEntrySchemaFromFieldDefinitions,
   getRemoteOriginUrlProjectSchema,
-  getValueContentSchemaFromFieldDefinition,
+  getUpdateEntrySchemaFromFieldDefinitions,
+  getValueSchemaFromFieldDefinition,
   gitCloneOptionsSchema,
   gitCommitSchema,
   gitInitOptionsSchema,