@jk2908/mdsrc 0.4.0 → 0.5.0

package/dist/index.js

@@ -132,11 +132,6 @@ function debounce(fn, wait) {
     }, wait);
   };
 }
-function dedent(str) {
-  return str.replace(/^\n/, "").replace(/\s+$/, "").split(`
-`).filter(Boolean).map((line) => line.replace(/^\s+/, "")).join(`
-`);
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -151,128 +146,151 @@ function deep(obj, path, value) {
   cur[parts.at(-1)] = value;
 }
 
-// src/index.ts
-var fileCache = new Map;
-var DEFAULT_COMPILE_OPTIONS = {
-  features: {
-    frontmatter: true
-  }
-};
-async function parse(frontmatter) {
-  if (!frontmatter)
-    return {};
-  const { kind, value } = frontmatter;
-  switch (kind) {
-    case "yaml": {
-      return (await import("yaml")).parse(value);
-    }
-    case "toml": {
-      return (await import("smol-toml")).parse(value);
-    }
-  }
-}
-async function create(dir, buildContext) {
-  const { logger: logger2, compileOptions = {} } = buildContext;
-  const { features, ...restCompileOptions } = compileOptions;
-  try {
-    const files = (await fs.readdir(dir)).filter((file) => path.extname(file) === ".md");
-    const filePaths = files.map((file) => path.join(dir, file));
-    if (!files.length) {
-      console.warn(`mdsrc: ${dir} is empty`);
-      return [];
-    }
-    return Promise.all(filePaths.map(async (filePath) => {
-      const file = path.basename(filePath);
-      const { html, frontmatter: rawFrontmatter } = markdownToHtml(await fs.readFile(filePath, "utf-8"), {
-        features: {
-          ...DEFAULT_COMPILE_OPTIONS.features,
-          ...features
-        },
-        ...restCompileOptions
-      });
-      const frontmatter = await parse(rawFrontmatter);
-      return {
-        ...frontmatter,
-        __mdsrc: {
-          slug: path.basename(file, ".md").toLowerCase().replace(/\s+/g, "-"),
-          filename: file
-        },
-        body: html.trim()
-      };
-    }));
-  } catch (err) {
-    logger2.error("[create]: failed to create entries", err);
-    return [];
-  }
-}
-async function maybeWrite(filePath, content) {
-  const cached = fileCache.get(filePath);
-  if (cached === content) {
-    try {
-      await fs.access(filePath);
-      return false;
-    } catch (err) {
-      if (!(err instanceof Error) || !("code" in err) || err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  if (cached === undefined) {
-    try {
-      const current = await fs.readFile(filePath, "utf-8");
-      fileCache.set(filePath, current);
-      if (current === content) {
-        fileCache.set(filePath, content);
-        return false;
-      }
-    } catch (err) {
-      if (!(err instanceof Error) || !("code" in err) || err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-  }
-  await fs.writeFile(filePath, content);
-  fileCache.set(filePath, content);
-  return true;
-}
+// src/types.ts
+var PRIMITIVE_NAMES = ["string", "number", "boolean", "date", "array"];
+var MODIFIER_NAMES = ["max", "min"];
+
+// src/validate.ts
 function validate(input, schema) {
   const validated = {};
   const issues = [];
   if (typeof input !== "object" || input === null) {
-    issues.push({ message: "Input must be an object" });
+    issues.push({ message: "Input must be an object", code: "INVALID_INPUT" });
     return { issues };
   }
+  const schemaKeys = new Set(Object.keys(schema).map((k) => parseKey(k).key));
+  for (const key in input) {
+    if (!schemaKeys.has(key)) {
+      issues.push({ message: `Unknown key: ${key}`, code: "UNKNOWN_KEY" });
+    }
+  }
+  if (issues.length)
+    return { issues };
   function walk(key, schemaValue, data) {
     const { optional, key: parsedKey } = parseKey(key);
     if (data === undefined) {
       if (!optional) {
-        issues.push({ message: `Missing required key: ${parsedKey}` });
+        issues.push({
+          message: `Missing required key: ${parsedKey}`,
+          code: "MISSING_REQUIRED"
+        });
       }
       return;
     }
     if (typeof schemaValue === "string") {
-      switch (schemaValue) {
-        case "string": {
+      const { types, modifiers } = parseSchemaValue(schemaValue);
+      for (const type of types) {
+        if (type === "string") {
           if (typeof data !== "string") {
-            issues.push({ message: `Key ${parsedKey} must be a string` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a string`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum length (${min})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum length (${max})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, data);
-          break;
-        }
-        case "number": {
+          return;
+        } else if (type === "number") {
           let num = data;
           if (typeof data === "string" && !Number.isNaN(Number(data))) {
             num = Number(data);
           }
           if (typeof num !== "number" || Number.isNaN(num)) {
-            issues.push({ message: `Key ${parsedKey} must be a number` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a number`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (num < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum size (${min})`,
+                  code: "INVALID_SIZE"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (num > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum size (${max})`,
+                  code: "INVALID_SIZE"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, num);
-          break;
-        }
-        case "boolean": {
+          return;
+        } else if (type === "boolean") {
           let bool = data;
           if (typeof data === "string") {
             if (data.toLowerCase() === "true") {
@@ -282,29 +300,151 @@ function validate(input, schema) {
             }
           }
           if (typeof bool !== "boolean") {
-            issues.push({ message: `Key ${parsedKey} must be a boolean` });
-            return;
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a boolean`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
           }
           deep(validated, parsedKey, bool);
-          break;
-        }
-        case "date": {
-          if (typeof data !== "string") {
-            issues.push({ message: `Key ${parsedKey} must be a date` });
-            return;
+          return;
+        } else if (type === "date") {
+          let date;
+          if (data instanceof Date) {
+            date = data;
+          } else if (typeof data === "string" || typeof data === "number") {
+            date = new Date(data);
+          } else {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a Date, string or number`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
           }
-          const date = new Date(data);
-          if (Number.isNaN(date.getTime())) {
-            issues.push({ message: `Key ${parsedKey} must be a valid date` });
-            return;
+          const dt = date.getTime();
+          if (Number.isNaN(dt)) {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be a valid date`,
+                code: "INVALID_DATE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = new Date(Number(modifiers.min));
+            if (Number.isNaN(min.getTime())) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to instance (Date)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (dt < min.getTime()) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum date (${min.toISOString()})`,
+                  code: "INVALID_DATE"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = new Date(Number(modifiers.max));
+            if (Number.isNaN(max.getTime())) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to instance (Date)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (dt > max.getTime()) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum date (${max.toISOString()})`,
+                  code: "INVALID_DATE"
+                });
+                return;
+              }
+              continue;
+            }
           }
           deep(validated, parsedKey, date.toISOString());
-          break;
+          return;
+        } else if (type === "array") {
+          if (!Array.isArray(data)) {
+            if (types.length === 1) {
+              issues.push({
+                message: `Key ${parsedKey} must be an array`,
+                code: "INVALID_TYPE"
+              });
+              return;
+            }
+            continue;
+          }
+          if (modifiers.min) {
+            const min = Number(modifiers.min);
+            if (Number.isNaN(min)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.min}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length < min) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be greater than or equal to minimum array length (${min})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          if (modifiers.max) {
+            const max = Number(modifiers.max);
+            if (Number.isNaN(max)) {
+              issues.push({
+                message: `Key ${parsedKey} contains a bad modifier (${modifiers.max}) that could not be converted to type (number)`,
+                code: "BAD_MODIFIER"
+              });
+              return;
+            }
+            if (data.length > max) {
+              if (types.length === 1) {
+                issues.push({
+                  message: `Key ${parsedKey} must be less than or equal to maximum array length (${max})`,
+                  code: "INVALID_LENGTH"
+                });
+                return;
+              }
+              continue;
+            }
+          }
+          deep(validated, parsedKey, data);
+          return;
         }
       }
+      issues.push({
+        message: `Key ${parsedKey} must be one of: ${types.join(", ")}`,
+        code: "INVALID_TYPE"
+      });
     } else {
       if (!isRecord(data)) {
-        issues.push({ message: `Key ${parsedKey} must be an object` });
+        issues.push({
+          message: `Key ${parsedKey} must be an object`,
+          code: "INVALID_TYPE"
+        });
         return;
       }
       const obj = data;
@@ -325,14 +465,136 @@ function parseKey(k) {
     key: optional ? k.slice(0, -1) : k
   };
 }
-function schemaValueToType(schema) {
+function parseSchemaValue(value) {
+  if (isRecord(value))
+    throw new Error("Cannot parse object schema values");
+  const parts = value.split("|");
+  const types = [];
+  const modifiers = {};
+  for (const p of parts) {
+    if (p.indexOf("=") > -1) {
+      const [m, v] = p.split("=");
+      if (!isModifierName(m))
+        throw new Error(`Unrecognised modifier: ${m}`);
+      modifiers[m] = v;
+    } else {
+      if (!isPrimitive(p))
+        throw new Error(`Unrecognised type: ${p}`);
+      types.push(p);
+    }
+  }
+  return { types, modifiers };
+}
+function isModifierName(name) {
+  return MODIFIER_NAMES.some((n) => n === name);
+}
+function isPrimitive(name) {
+  return PRIMITIVE_NAMES.some((n) => n === name);
+}
+
+// src/index.ts
+var DEFAULT_COMPILE_OPTIONS = {
+  features: {
+    frontmatter: true
+  }
+};
+async function parse(frontmatter) {
+  if (!frontmatter)
+    return {};
+  const { kind, value } = frontmatter;
+  switch (kind) {
+    case "yaml": {
+      return (await import("yaml")).parse(value);
+    }
+    case "toml": {
+      return (await import("smol-toml")).parse(value);
+    }
+  }
+}
+async function create(dir, buildContext) {
+  const { logger: logger2, compileOptions = {} } = buildContext;
+  const { features, ...restCompileOptions } = compileOptions;
+  try {
+    const files = (await fs.readdir(dir)).filter((file) => path.extname(file) === ".md");
+    const filePaths = files.map((file) => path.join(dir, file));
+    if (!files.length) {
+      logger2.warn(`mdsrc: ${dir} is empty`);
+      return [];
+    }
+    return Promise.all(filePaths.map(async (filePath) => {
+      const file = path.basename(filePath);
+      const { html, frontmatter: rawFrontmatter } = markdownToHtml(await fs.readFile(filePath, "utf-8"), {
+        features: {
+          ...DEFAULT_COMPILE_OPTIONS.features,
+          ...features
+        },
+        ...restCompileOptions
+      });
+      const frontmatter = await parse(rawFrontmatter);
+      return {
+        ...frontmatter,
+        __mdsrc: {
+          slug: path.basename(file, ".md").toLowerCase().replace(/\s+/g, "-"),
+          filename: file
+        },
+        body: html.trim()
+      };
+    }));
+  } catch (err) {
+    logger2.error("[create]: failed to create entries", err);
+    throw err;
+  }
+}
+function isENOENT(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+var fileCache = new Map;
+var FILE_CACHE_MAX_SIZE = 100;
+function setFileCache(filePath, content) {
+  fileCache.delete(filePath);
+  if (fileCache.size >= FILE_CACHE_MAX_SIZE) {
+    const lru = fileCache.keys().next().value;
+    if (lru !== undefined) {
+      fileCache.delete(lru);
+    }
+  }
+  fileCache.set(filePath, content);
+}
+function getFileCache(filePath) {
+  const content = fileCache.get(filePath);
+  if (content !== undefined) {
+    setFileCache(filePath, content);
+  }
+  return content;
+}
+async function maybeWrite(filePath, content) {
+  const cached = getFileCache(filePath);
+  if (cached !== content) {
+    await fs.writeFile(filePath, content);
+    setFileCache(filePath, content);
+    return true;
+  }
+  try {
+    if (await fs.readFile(filePath, "utf-8") === content) {
+      setFileCache(filePath, content);
+      return false;
+    }
+  } catch (err) {
+    if (!isENOENT(err))
+      throw err;
+  }
+  await fs.writeFile(filePath, content);
+  setFileCache(filePath, content);
+  return true;
+}
+function schemaToType(schema) {
   const fields = Object.entries(schema).map(([k, v]) => {
     const { key, optional } = parseKey(k);
     let type;
     if (typeof v === "string") {
-      type = v === "date" ? "string" : v;
+      type = v === "date" ? "string" : v === "array" ? "any[]" : v;
     } else {
-      type = schemaValueToType(v);
+      type = schemaToType(v);
     }
     return `${key}${optional ? "?" : ""}: ${type}`;
   }).join(`
@@ -349,24 +611,19 @@ async function build(src, buildContext) {
     await fs.mkdir(outDir, { recursive: true });
     for (const collection of src) {
       const raw = await create(path.join(process.cwd(), collection.dir), buildContext);
-      const validated = await Promise.all(raw.map(async (item) => {
-        try {
-          const { body, __mdsrc, ...metadata } = item;
-          const res = validate(metadata, collection.schema);
-          if (res.issues)
-            throw new Error(JSON.stringify(res.issues, null, 2));
-          return {
-            ...res.value,
-            body,
-            __mdsrc
-          };
-        } catch (err) {
-          logger2.error(`[buildStart]: failed to validate item in ${collection.name}`, err);
-          return null;
-        }
-      }));
+      const validated = raw.map((item) => {
+        const { body, __mdsrc, ...metadata } = item;
+        const res = validate(metadata, collection.schema);
+        if (res.issues)
+          throw new Error(JSON.stringify(res.issues, null, 2));
+        return {
+          ...res.value,
+          body,
+          __mdsrc
+        };
+      });
       collections[collection.name] = {
-        items: validated.filter((e) => e !== null),
+        items: validated,
         schema: collection.schema
       };
     }
@@ -374,7 +631,7 @@ async function build(src, buildContext) {
     const promises = [];
     promises.push(maybeWrite(path.join(outDir, "types.ts"), `
 					${names.map((name) => `
-								export type ${capitalise(name)} = ${schemaValueToType(collections[name].schema)} & {
+								export type ${capitalise(name)} = ${schemaToType(collections[name].schema)} & {
 									body: string,
 									__mdsrc: {
 										slug: string
@@ -506,15 +763,13 @@ function mdsrc(config) {
       server.watcher.on("add", (p) => rebuild("add", p)).on("change", (p) => rebuild("change", p)).on("unlink", (p) => rebuild("unlink", p));
     },
     resolveId(id) {
-      if (id === PKG_NAME) {
+      if (id === PKG_NAME)
         return path.join(outDir, "index.js");
-      }
       if (id.startsWith(`${PKG_NAME}/`)) {
         const subpath = id.slice(PKG_NAME.length + 1);
         const match = buildContext.names.find((name) => name === subpath || toModuleName(name) === subpath);
-        if (match) {
+        if (match)
           return path.join(outDir, `${toModuleName(match)}.js`);
-        }
       }
       return null;
     }
@@ -523,42 +778,19 @@ function mdsrc(config) {
 function toModuleName(name) {
   return name.toLowerCase();
 }
-if (import.meta.vitest) {
-  const { it, expect, describe } = import.meta.vitest;
-  const now = Date.now();
-  const yaml = {
-    kind: "yaml",
-    value: dedent(`
-			title: mdsrc
-			date: ${now}
-		`)
-  };
-  const toml = {
-    kind: "toml",
-    value: dedent(`
-			title = "mdsrc"
-			date = ${now}
-		`)
-  };
-  describe("markdown parsing", () => {
-    it("parses frontmatter", async () => {
-      for (const f of [yaml, toml]) {
-        const frontmatter = await parse(f);
-        expect(frontmatter).toEqual({
-          title: "mdsrc",
-          date: now
-        });
-      }
-    });
-    it("returns empty object for missing frontmatter", async () => {
-      const frontmatter = await parse(null);
-      expect(frontmatter).toEqual({});
-    });
-  });
-}
 export {
+  toModuleName,
+  setFileCache,
+  schemaToType,
+  parse,
+  maybeWrite,
+  isENOENT,
+  getFileCache,
+  fileCache,
   mdsrc as default,
-  create
+  create,
+  FILE_CACHE_MAX_SIZE,
+  DEFAULT_COMPILE_OPTIONS
 };
 
-//# debugId=0F1D108961D2552964756E2164756E21
+//# debugId=49D42D1A4493323164756E2164756E21