1 files changed, 3 insertions, 100 deletions

diff --git a/src/content.config.ts b/src/content.config.ts
index f652cc3..821faf5 100644
--- a/src/content.config.ts
+++ b/src/content.config.ts
@@ -1,114 +1,17 @@
 import { file, glob } from "astro/loaders";
-import { defineCollection, reference, z } from "astro:content";
+import { defineCollection, type z } from "astro:content";
 //import { parse } from "@std/toml";
 import { parse } from "toml";
-import { EntityTypesEnum, KeywordsEnum, LicensesEnum } from "./consts.ts";
-import { get, instanciate } from "./utils/anonymous.ts";
-import { isValidLocale } from "./utils/lang.ts";
-
-const Blog = z.object({
-  title: z.string().trim(),
-  subtitle: z.string().trim().optional(),
-  description: z.string().trim().optional(),
-  keywords: z.array(KeywordsEnum).optional().refine(
-    (keywords) => new Set(keywords).size === (keywords?.length ?? 0),
-    {
-      message: "Keywords must be unique",
-    },
-  ).transform((keywords) =>
-    keywords !== undefined ? new Set(keywords).values().toArray() : undefined
-  ),
-  dateCreated: z.coerce.date(),
-  dateUpdated: z.coerce.date().optional(),
-  locationCreated: z.string().trim().optional(),
-  relatedPosts: z.array(reference("blog")).default([]).refine(
-    (posts) => new Set(posts).size === (posts?.length ?? 0),
-    {
-      message: "Related posts referenced multiple times",
-    },
-  ).transform((x) => new Set(x)).transform((set) => set.values().toArray()),
-  lang: z.string().trim().refine(isValidLocale),
-  translationOf: reference("blog").optional(),
-  signers: z.array(
-    z.object({ entity: reference("entity"), role: EntityTypesEnum }),
-  ).optional().refine(
-    (signers) => {
-      if (signers === undefined) return true;
-      return signers.filter((s) => s.role === "author").length <= 1;
-    },
-    {
-      message: "There can only be one author",
-    },
-  ).refine(
-    (signers) => {
-      const ids = signers?.map(get("entity")) ?? [];
-      return new Set(ids).size === ids.length;
-    },
-    {
-      message: "Reusing signers",
-    },
-    //).transform((signers) =>
-    //  Object.fromEntries(new Map(signers?.map(({ entity, ...rest }) => [entity, rest]) ?? []))
-  ),
-  license: LicensesEnum,
-}).refine(
-  ({ dateCreated, dateUpdated }) =>
-    dateUpdated === undefined || dateCreated.getTime() <= dateUpdated.getTime(),
-  { message: "Update before creation" },
-).refine(
-  ({ translationOf, keywords }) =>
-    translationOf !== undefined || (keywords?.length ?? 0) > 0,
-  {
-    message: "Originals must include at least one keyword",
-    path: ["keywords"],
-  },
-).refine(
-  ({ translationOf, keywords }) =>
-    (translationOf === undefined) !== ((keywords?.length ?? 0) <= 0),
-  {
-    message: "we will use this information from the original, " +
-      "so no need to specify it for translations",
-    path: ["keywords"],
-  },
-).refine(
-  ({ translationOf, relatedPosts }) =>
-    (translationOf === undefined) || (relatedPosts.length <= 0),
-  {
-    message: "we will use this information from the original, " +
-      "so no need to specify it for translations",
-    path: ["relatedPosts"],
-  },
-).refine(
-  ({ translationOf, signers = [] }) =>
-    (translationOf === undefined) ||
-    (signers.values().every(({ role }) => role !== "translator")),
-  {
-    message: "There can't be translator signers on non translated work",
-    path: ["signers"],
-  },
-);
+import { Blog, Entity } from "./lib/collection/schemas.ts";
 
 const blog = defineCollection({
   loader: glob({ base: "./public/blog", pattern: "+([0-9a-z-]).md" }),
   schema: Blog,
 });
 
-export type Blog = z.infer<typeof Blog>;
-
-const Entity = z.object({
-  websites: z.array(z.string().url().trim()).default([]).transform((websites) =>
-    websites.map(instanciate(URL))
-  ),
-  publickey: z.object({
-    armor: z.string().trim(),
-  }),
-});
-
-type Entity = z.infer<typeof Entity>;
-
 const entity = defineCollection({
   loader: file("./src/content/entities.toml", {
-    parser: (text) => parse(text).entities as Entity[],
+    parser: (text) => parse(text).entities as z.infer<typeof Entity>[],
   }),
   schema: Entity,
 });