@content-collections/core 0.3.1 → 0.4.1

package/README.md

@@ -110,6 +110,18 @@ Transform your content into type-safe data collections. Eliminate the need for m
 
 For a more detailed guide, please refer to the [documentation](https://content-collections.dev/docs/guides/getting-started).
 
+## Sponsors
+
+<a href="https://supastarter.dev">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./assets/sponsors/supastarter/dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="./assets/sponsors/supastarter/light.svg">
+    <img alt="supastarter" src="./assets/sponsors/supastarter/light.svg" height="64">
+  </picture>
+</a>
+
+### [Become a sponsor](https://github.com/sponsors/sdorra)
+
 ## License
 
 Content Collections is licensed under the [MIT License](./LICENSE).

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ZodRawShape, z, ZodObject, ZodTypeAny, ZodString } from 'zod';
+import z, { ZodRawShape, z as z$1, ZodObject, ZodTypeAny, ZodString } from 'zod';
 import { parse } from 'yaml';
 
 type Parsers = typeof parsers;
@@ -23,6 +23,14 @@ declare const parsers: {
 
 type CacheFn = <TInput, TOutput>(input: TInput, compute: (input: TInput) => Promise<TOutput> | TOutput) => Promise<TOutput>;
 
+declare const literalSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodUndefined]>;
+type Literal = z.infer<typeof literalSchema>;
+type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+declare const jsonObjectScheme: z.ZodRecord<z.ZodString, z.ZodType<Json, z.ZodTypeDef, Json>>;
+type JSONObject = z.infer<typeof jsonObjectScheme>;
+
 type Meta = {
     filePath: string;
     fileName: string;
@@ -38,14 +46,14 @@ type AddContent<TShape extends ZodRawShape> = TShape extends {
 } ? TShape : TShape & WithContent;
 type GetParsedShape<TParser extends Parser, TShape extends ZodRawShape> = Parsers[TParser]["hasContent"] extends true ? AddContent<TShape> : TShape;
 type GetShape<TParser extends Parser | undefined, TShape extends ZodRawShape> = TParser extends Parser ? GetParsedShape<TParser, TShape> : AddContent<TShape>;
-type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z.infer<ZodObject<GetShape<TParser, TShape>>> & {
+type Schema<TParser extends Parser | undefined, TShape extends ZodRawShape> = z$1.infer<ZodObject<GetShape<TParser, TShape>>> & {
     _meta: Meta;
 };
 type Context = {
     documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["parser"], TCollection["schema"]>>;
     cache: CacheFn;
 };
-type Z = typeof z;
+type Z = typeof z$1;
 type CollectionRequest<TName extends string, TShape extends ZodRawShape, TParser, TSchema, TTransformResult, TDocument> = {
     name: TName;
     parser?: TParser;
@@ -62,7 +70,13 @@ type Collection<TName extends string, TShape extends ZodRawShape, TParser extend
     parser: TParser;
 };
 type AnyCollection = Collection<any, ZodRawShape, Parser, any, any, any>;
-declare function defineCollection<TName extends string, TShape extends ZodRawShape, TParser extends Parser = "frontmatter", TSchema = Schema<TParser, TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TParser, TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TParser, TSchema, TTransformResult, TDocument>;
+type NonJSONObjectError = "The return type of the transform function must be an valid JSONObject, the following type is not valid:";
+declare const InvalidReturnTypeSymbol: unique symbol;
+type InvalidReturnType<TMessage extends string, TObject> = {
+    [InvalidReturnTypeSymbol]: TMessage;
+    object: TObject;
+};
+declare function defineCollection<TName extends string, TShape extends ZodRawShape, TParser extends Parser = "frontmatter", TSchema = Schema<TParser, TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TParser, TShape> : Awaited<TTransformResult>, TResult = TDocument extends JSONObject ? Collection<TName, TShape, TParser, TSchema, TTransformResult, TDocument> : InvalidReturnType<NonJSONObjectError, TDocument>>(collection: CollectionRequest<TName, TShape, TParser, TSchema, TTransformResult, TDocument>): TResult;
 type Cache = "memory" | "file" | "none";
 type Configuration<TCollections extends Array<AnyCollection>> = {
     collections: TCollections;
@@ -107,12 +121,17 @@ type TransformerEvents = {
         file: CollectionFile;
         error: TransformError;
     };
+    "transformer:result-error": {
+        collection: AnyCollection;
+        document: any;
+        error: TransformError;
+    };
     "transformer:error": {
         collection: AnyCollection;
         error: TransformError;
     };
 };
-type ErrorType$1 = "Validation" | "Configuration" | "Transform";
+type ErrorType$1 = "Validation" | "Configuration" | "Transform" | "Result";
 declare class TransformError extends Error {
     type: ErrorType$1;
     constructor(type: ErrorType$1, message: string);
@@ -167,7 +186,7 @@ declare function createBuilder(configurationPath: string, options?: Options): Pr
         unsubscribe: () => Promise<void>;
     }>;
     on: {
-        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:error" | "watcher:file-changed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+        <TKey extends "builder:start" | "builder:end" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "watcher:file-changed">(key: TKey, listener: (event: Events[TKey]) => void): void;
         <TKey_1 extends "_error" | "_all">(key: TKey_1, listener: (event: SystemEvents[TKey_1]) => void): void;
     };
 }>;

package/dist/index.js

@@ -16,6 +16,7 @@ function orderByPath(a, b) {
 }
 
 // src/config.ts
+var InvalidReturnTypeSymbol = Symbol(`InvalidReturnType`);
 function defineCollection(collection) {
   let typeName = collection.typeName;
   if (!typeName) {
@@ -44,7 +45,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "@content-collections/core",
-  version: "0.3.1",
+  version: "0.4.1",
   type: "module",
   main: "dist/index.js",
   types: "./dist/index.d.ts",
@@ -314,11 +315,18 @@ async function createJavaScriptFile(directory, configuration) {
   content += "export { " + collections.join(", ") + " };\n";
   await fs2.writeFile(path3.join(directory, "index.js"), content, "utf-8");
 }
+function createImportPath(directory, target) {
+  let importPath = path3.posix.join(...path3.relative(directory, target).split(path3.sep));
+  if (!importPath.startsWith(".")) {
+    importPath = "./" + importPath;
+  }
+  return importPath;
+}
 async function createTypeDefinitionFile(directory, configuration) {
   if (!configuration.generateTypes) {
     return;
   }
-  const importPath = path3.relative(directory, configuration.path);
+  const importPath = createImportPath(directory, configuration.path);
   let content = `import configuration from "${importPath}";
 import { GetTypeByName } from "@content-collections/core";
 `;
@@ -348,7 +356,23 @@ async function createWriter(directory) {
 
 // src/transformer.ts
 import { basename, dirname, extname } from "path";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+
+// src/json.ts
+import z2 from "zod";
+var literalSchema = z2.union([
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null(),
+  z2.undefined()
+]);
+var jsonSchema = z2.lazy(
+  () => z2.union([literalSchema, z2.array(jsonSchema), z2.record(jsonSchema)])
+);
+var jsonObjectScheme = z2.record(jsonSchema);
+
+// src/transformer.ts
 var TransformError = class extends Error {
   type;
   constructor(type, message) {
@@ -367,10 +391,10 @@ function createTransformer(emitter, cacheManager) {
   function createSchema(parserName, schema) {
     const parser = parsers[parserName];
     if (!parser.hasContent) {
-      return z2.object(schema);
+      return z3.object(schema);
     }
-    return z2.object({
-      content: z2.string(),
+    return z3.object({
+      content: z3.string(),
       ...schema
     });
   }
@@ -433,12 +457,16 @@ function createTransformer(emitter, cacheManager) {
     if (collection.transform) {
       const docs = [];
       for (const doc of collection.documents) {
-        const cache = cacheManager.cache(collection.name, doc.document._meta.path);
+        const cache = cacheManager.cache(
+          collection.name,
+          doc.document._meta.path
+        );
         const context = createContext(collections, cache);
         try {
+          const document = await collection.transform(doc.document, context);
           docs.push({
             ...doc,
-            document: await collection.transform(doc.document, context)
+            document
           });
           await cache.tidyUp();
         } catch (error) {
@@ -460,13 +488,30 @@ function createTransformer(emitter, cacheManager) {
     }
     return collection.documents;
   }
+  async function validateDocuments(collection, documents) {
+    const docs = [];
+    for (const doc of documents) {
+      let parsedData = await jsonObjectScheme.safeParseAsync(doc.document);
+      if (parsedData.success) {
+        docs.push(doc);
+      } else {
+        emitter.emit("transformer:result-error", {
+          collection,
+          document: doc.document,
+          error: new TransformError("Result", parsedData.error.message)
+        });
+      }
+    }
+    return docs;
+  }
   return async (untransformedCollections) => {
     const promises = untransformedCollections.map(
       (collection) => parseCollection(collection)
     );
     const collections = await Promise.all(promises);
     for (const collection of collections) {
-      collection.documents = await transformCollection(collections, collection);
+      const documents = await transformCollection(collections, collection);
+      collection.documents = await validateDocuments(collection, documents);
     }
     return collections;
   };
@@ -476,9 +521,9 @@ function createTransformer(emitter, cacheManager) {
 import micromatch from "micromatch";
 import path4 from "path";
 function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-  function findCollection(filePath) {
+  function findCollections(filePath) {
     const resolvedFilePath = path4.resolve(filePath);
-    return collections.find((collection) => {
+    return collections.filter((collection) => {
       return resolvedFilePath.startsWith(
         path4.resolve(baseDirectory, collection.directory)
       );
@@ -494,51 +539,56 @@ function createSynchronizer(readCollectionFile, collections, baseDirectory = "."
     return relativePath;
   }
   function resolve(filePath) {
-    const collection = findCollection(filePath);
-    if (!collection) {
-      return null;
-    }
-    const relativePath = createRelativePath(collection.directory, filePath);
-    if (!micromatch.isMatch(relativePath, collection.include)) {
-      return null;
-    }
-    return {
-      collection,
-      relativePath
-    };
+    const collections2 = findCollections(filePath);
+    return collections2.map((collection) => {
+      const relativePath = createRelativePath(collection.directory, filePath);
+      return {
+        collection,
+        relativePath
+      };
+    }).filter(({ collection, relativePath }) => {
+      return micromatch.isMatch(relativePath, collection.include);
+    });
   }
   function deleted(filePath) {
-    const resolved = resolve(filePath);
-    if (!resolved) {
+    const resolvedCollections = resolve(filePath);
+    if (resolvedCollections.length === 0) {
       return false;
     }
-    const { collection, relativePath } = resolved;
-    const index = collection.files.findIndex(
-      (file) => file.path === relativePath
-    );
-    const deleted2 = collection.files.splice(index, 1);
-    return deleted2.length > 0;
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file) => file.path === relativePath
+      );
+      const deleted2 = collection.files.splice(index, 1);
+      if (deleted2.length > 0) {
+        changed2 = true;
+      }
+    }
+    return changed2;
   }
   async function changed(filePath) {
-    const resolved = resolve(filePath);
-    if (!resolved) {
+    const resolvedCollections = resolve(filePath);
+    if (resolvedCollections.length === 0) {
       return false;
     }
-    const { collection, relativePath } = resolved;
-    const index = collection.files.findIndex(
-      (file2) => file2.path === relativePath
-    );
-    const file = await readCollectionFile(collection, relativePath);
-    if (!file) {
-      return false;
-    }
-    if (index === -1) {
-      collection.files.push(file);
-      collection.files.sort(orderByPath);
-    } else {
-      collection.files[index] = file;
+    let changed2 = false;
+    for (const { collection, relativePath } of resolvedCollections) {
+      const index = collection.files.findIndex(
+        (file2) => file2.path === relativePath
+      );
+      const file = await readCollectionFile(collection, relativePath);
+      if (file) {
+        changed2 = true;
+        if (index === -1) {
+          collection.files.push(file);
+          collection.files.sort(orderByPath);
+        } else {
+          collection.files[index] = file;
+        }
+      }
     }
-    return true;
+    return changed2;
   }
   return {
     deleted,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@content-collections/core",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",