@cedgetec-utils/astro-components 1.2.0 → 1.4.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@cedgetec-utils/astro-components",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./src/components/index.ts",
+    "./libs": "./src/libs/index.ts"
   },
   "files": [
     "src",
@@ -13,10 +14,15 @@
     "astro-component"
   ],
   "scripts": {},
+  "dependencies": {
+    "astro": "^5.17.1"
+  },
   "devDependencies": {
-    "astro": "^5.15.3"
+    "oxfmt": "^0.28.0",
+    "oxlint": "^1.43.0",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "astro": "^5.0.0"
+    "astro": "^5.17.1"
   }
-}
+}

package/src/components/index.ts

@@ -0,0 +1,7 @@
+// Do not write code directly here, instead use the `src` folder!
+// Then, use this file to export everything you want your user to access.
+
+export { default as DirectusImage } from "./DirectusImage.astro";
+export type { DirectusImageData } from "./DirectusImage.astro";
+export { default as Head } from "./Head.astro";
+export { default as Matomo } from "./Matomo.astro";

package/src/libs/directus.ts

@@ -0,0 +1,184 @@
+import type { ZodObject, ZodRawShape, ZodSchema } from "astro/zod"
+import { defineCollection } from "astro:content"
+import { z } from "astro/zod"
+
+async function fetchWithRetry(
+  url: string,
+  options: RequestInit = {},
+  retries = 10,
+  delay = 200,
+): Promise<Response> {
+  try {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 10_000)
+
+    const res = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+    })
+
+    clearTimeout(timeout)
+
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}`)
+    }
+
+    return res
+  } catch (err) {
+    if (retries <= 0) throw err
+    console.warn(`Fetch failed, retrying (${retries})…`)
+    await new Promise((r) => setTimeout(r, delay))
+    return fetchWithRetry(url, options, retries - 1, delay * 1.5)
+  }
+}
+
+function getZodSchemaPaths(schema: ZodSchema, prefix = ""): string[] {
+  const paths: string[] = []
+
+  // Unwrap optional, nullable, and effects (transforms, refinements, etc.)
+  let unwrapped = schema
+  while (
+    unwrapped instanceof z.ZodOptional ||
+    unwrapped instanceof z.ZodNullable ||
+    unwrapped instanceof z.ZodEffects
+  ) {
+    if (unwrapped instanceof z.ZodEffects) {
+      unwrapped = unwrapped._def.schema
+    } else {
+      unwrapped = unwrapped._def.innerType
+    }
+  }
+
+  // Handle ZodObject
+  if (unwrapped instanceof z.ZodObject) {
+    const shape = unwrapped.shape
+    for (const key in shape) {
+      const fieldPath = prefix ? `${prefix}.${key}` : key
+      const fieldSchema = shape[key]
+
+      // Recursively get paths for nested schemas
+      const nestedPaths = getZodSchemaPaths(fieldSchema, fieldPath)
+
+      if (nestedPaths.length > 0) {
+        paths.push(...nestedPaths)
+      } else {
+        paths.push(fieldPath)
+      }
+    }
+  } // Handle ZodArray
+  else if (unwrapped instanceof z.ZodArray) {
+    const elementSchema = unwrapped._def.type
+    // Get paths from the array element schema without adding array indices
+    const nestedPaths = getZodSchemaPaths(elementSchema, prefix)
+    paths.push(...nestedPaths)
+  } // Handle ZodDiscriminatedUnion (for Directus M2A relationships)
+  else if (unwrapped instanceof z.ZodDiscriminatedUnion) {
+    const discriminator = unwrapped._def.discriminator as string
+    const options = unwrapped._def.options as z.ZodObject<any>[]
+
+    // Always include the discriminator field
+    paths.push(prefix ? `${prefix}.${discriminator}` : discriminator)
+
+    for (const option of options) {
+      const shape = option.shape
+      // Get the literal value of the discriminator (e.g., "pages_content_heading")
+      let discriminatorValue: string | undefined
+      const discriminatorSchema = shape[discriminator]
+      if (discriminatorSchema instanceof z.ZodLiteral) {
+        discriminatorValue = discriminatorSchema._def.value as string
+      }
+
+      // Process other fields in this variant
+      for (const key in shape) {
+        if (key === discriminator) continue
+
+        const fieldPath = prefix ? `${prefix}.${key}` : key
+        const fieldSchema = shape[key]
+
+        // For M2A "item" fields, use Directus collection-specific syntax
+        if (key === "item" && discriminatorValue) {
+          const itemPaths = getZodSchemaPaths(fieldSchema, "")
+          for (const itemPath of itemPaths) {
+            // Use syntax: item:collection_name.field
+            paths.push(`${fieldPath}:${discriminatorValue}.${itemPath}`)
+          }
+        } else {
+          const nestedPaths = getZodSchemaPaths(fieldSchema, fieldPath)
+          paths.push(...nestedPaths)
+        }
+      }
+    }
+  } // Base case: primitive types
+  else {
+    if (prefix) {
+      paths.push(prefix)
+    }
+  }
+
+  return paths
+}
+
+export class Directus {
+  #apiDomain: string
+
+  constructor(apiDomain: string) {
+    this.#apiDomain = apiDomain
+  }
+
+  async #query(collection: string, fields?: string[]) {
+    const response = await fetchWithRetry(
+      `https://${this.#apiDomain}/items/${collection}${
+        fields && `?fields=${fields.join(",")}`
+      }`,
+    )
+
+    const data = await response.json()
+
+    return data.data
+  }
+
+  collection<T extends ZodRawShape>(name: string, schema: ZodObject<T>) {
+    const schemaWithId = schema.extend({ id: z.coerce.string() })
+    return defineCollection({
+      schema: schemaWithId,
+      loader: async () => {
+        const result = await this.#query(name, getZodSchemaPaths(schemaWithId))
+        if (Array.isArray(result)) {
+          return result
+        }
+
+        return [result]
+      },
+    })
+  }
+
+  imageSchema() {
+    return z
+      .object({
+        id: z.string(),
+        type: z.string(),
+        title: z.string(),
+        modified_on: z.string(),
+        width: z.number().nullish(),
+        height: z.number().nullish(),
+      })
+      .transform((image) => ({
+        ...image,
+        url: `https://${this.#apiDomain}/assets/${image.id}`,
+      }))
+  }
+
+  fileSchema() {
+    return z
+      .object({
+        id: z.string(),
+        type: z.string(),
+        title: z.string(),
+        modified_on: z.string(),
+      })
+      .transform((file) => ({
+        ...file,
+        url: `https://${this.#apiDomain}/assets/${file.id}`,
+      }))
+  }
+}

package/src/libs/index.ts

@@ -0,0 +1,4 @@
+// Do not write code directly here, instead use the `src` folder!
+// Then, use this file to export everything you want your user to access.
+
+export { Directus } from "./directus"

package/index.ts

@@ -1,7 +0,0 @@
-// Do not write code directly here, instead use the `src` folder!
-// Then, use this file to export everything you want your user to access.
-
-export { default as DirectusImage } from "./src/DirectusImage.astro";
-export type { DirectusImageData } from "./src/DirectusImage.astro";
-export { default as Head } from "./src/Head.astro";
-export { default as Matomo } from "./src/Matomo.astro";