@content-collections/core 0.1.0

package/src/events.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from "node:events";
+import { BuilderEvents } from "./builder";
+import { CollectorEvents } from "./collector";
+import { TransformerEvents } from "./transformer";
+import { WatcherEvents } from "./watcher";
+
+type EventMap = Record<string, object>;
+
+type EventWithError = {
+  error: Error;
+};
+
+type SystemEvent = {
+  _event: string;
+};
+
+type ErrorEvent = EventWithError & SystemEvent;
+
+export type Events = BuilderEvents &
+  CollectorEvents &
+  TransformerEvents &
+  WatcherEvents;
+
+export type SystemEvents = {
+  _error: ErrorEvent;
+  _all: SystemEvent;
+};
+
+type Keys<TEvents extends EventMap> = keyof TEvents & string;
+type Listener<TEvent> = (event: TEvent) => void;
+
+function isEventWithError(event: unknown): event is EventWithError {
+  return typeof event === "object" && event !== null && "error" in event;
+}
+
+export function createEmitter<TEvents extends EventMap>() {
+  const emitter = new EventEmitter();
+
+  function on<TKey extends Keys<TEvents>>(
+    key: TKey,
+    listener: Listener<TEvents[TKey]>
+  ): void;
+
+  function on<TKey extends Keys<SystemEvents>>(
+    key: TKey,
+    listener: Listener<SystemEvents[TKey]>
+  ): void;
+
+  function on(key: string, listener: Listener<any>) {
+    emitter.on(key, listener);
+  }
+
+  function emit<TKey extends Keys<TEvents>>(key: TKey, event: TEvents[TKey]) {
+    emitter.emit(key, event);
+
+    if (isEventWithError(event)) {
+      emitter.emit("_error", {
+        ...event,
+        _event: key,
+      });
+    }
+
+    emitter.emit("_all", {
+      ...event,
+      _event: key,
+    });
+  }
+
+  return {
+    on,
+    emit,
+  };
+}
+
+export type Emitter = ReturnType<typeof createEmitter<Events>>;

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./config";
+export * from "./builder";
+export type { GetTypeByName, Modification } from "./types";
+
+export { TransformError } from "./transformer";
+export { CollectError } from "./collector";
+export { ConfigurationError } from "./configurationReader";

package/src/synchronizer.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from "vitest";
+import { createSynchronizer } from "./synchronizer";
+import { CollectionFile } from "./types";
+
+describe("synchronizer", () => {
+  async function noopCollectionFileReader(): Promise<CollectionFile | null> {
+    return null;
+  }
+
+  function createCollectionFileReader(collectionFile: CollectionFile) {
+    return async (_: string, filePath: string) => {
+      if (filePath !== collectionFile.path) {
+        return null;
+      }
+
+      return collectionFile;
+    };
+  }
+
+  it("should add new file", async () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [],
+    };
+
+    const synchronizer = createSynchronizer(
+      createCollectionFileReader({
+        data: {
+          content: "changed"
+        },
+        path: "new.md",
+      }),
+      [collection]
+    );
+    expect(await synchronizer.changed("content/new.md")).toBe(true);
+
+    expect(collection.files.length).toBe(1);
+  });
+
+  it("should delete file", () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [
+        {
+          data: {
+            content: ""
+          },
+          path: "new.md",
+        },
+      ],
+    };
+
+    const synchronizer = createSynchronizer(noopCollectionFileReader, [
+      collection,
+    ]);
+    synchronizer.deleted("content/new.md");
+
+    expect(collection.files.length).toBe(0);
+  });
+
+  it("should change file", async () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [
+        {
+          data: {
+            content: ""
+          },
+          path: "new.md",
+        },
+      ],
+    };
+
+    const synchronizer = createSynchronizer(
+      createCollectionFileReader({
+        data: {
+          content: "changed"
+        },
+        path: "new.md",
+      }),
+      [collection]
+    );
+
+    expect(await synchronizer.changed("content/new.md")).toBe(true);
+    expect(collection.files[0]?.data.content).toBe("changed");
+  });
+
+  it("should not add file, if path is not in collection directory", async () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [],
+    };
+
+    const synchronizer = createSynchronizer(
+      createCollectionFileReader({
+        data: {
+          content: "changed"
+        },
+        path: "other/new.md",
+      }),
+      [collection]
+    );
+    expect(await synchronizer.changed("other/new.md")).toBe(false);
+
+    expect(collection.files.length).toBe(0);
+  });
+
+  it("should not add file, if path is not included", async () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [],
+    };
+
+    const synchronizer = createSynchronizer(
+      createCollectionFileReader({
+        data: {
+          content: "changed"
+        },
+        path: "content/new.html",
+      }),
+      [collection]
+    );
+    expect(await synchronizer.changed("content/new.html")).toBe(false);
+
+    expect(collection.files.length).toBe(0);
+  });
+
+  it("should not delete file, if path is not in collection directory", () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [
+        {
+          data: {
+            content: ""
+          },
+          path: "new.md",
+        },
+      ],
+    };
+
+    const synchronizer = createSynchronizer(noopCollectionFileReader, [
+      collection,
+    ]);
+    synchronizer.deleted("other/new.md");
+
+    expect(collection.files.length).toBe(1);
+  });
+
+  it("should not delete file, if path is not included", () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [
+        {
+          data: {
+            content: ""
+          },
+          path: "new.md",
+        },
+      ],
+    };
+
+    const synchronizer = createSynchronizer(noopCollectionFileReader, [
+      collection,
+    ]);
+    synchronizer.deleted("content/new.html");
+
+    expect(collection.files.length).toBe(1);
+  });
+
+  it("should not sync file, if file could not be read", async () => {
+    const collection = {
+      directory: "content",
+      include: "**/*.md",
+      files: [],
+    };
+
+    const synchronizer = createSynchronizer(
+      noopCollectionFileReader,
+      [collection]
+    );
+
+    expect(await synchronizer.changed("content/new.md")).toBe(false);
+    expect(collection.files.length).toBe(0);
+  });
+});

package/src/synchronizer.ts

@@ -0,0 +1,103 @@
+import micromatch from "micromatch";
+import { CollectionFile, FileCollection, ResolvedCollection } from "./types";
+import path from "node:path";
+
+type CollectionFileReader = (
+  directory: string,
+  filePath: string
+) => Promise<CollectionFile | null>;
+
+export function createSynchronizer<T extends FileCollection>(
+  readCollectionFile: CollectionFileReader,
+  collections: Array<ResolvedCollection<T>>,
+  baseDirectory: string = "."
+) {
+  function findCollection(filePath: string) {
+    const resolvedFilePath = path.resolve(filePath);
+    return collections.find((collection) => {
+      return resolvedFilePath.startsWith(
+        path.resolve(baseDirectory, collection.directory)
+      );
+    });
+  }
+
+  function createRelativePath(collectionPath: string, filePath: string) {
+    const resolvedCollectionPath = path.resolve(baseDirectory, collectionPath);
+    const resolvedFilePath = path.resolve(filePath);
+
+    let relativePath = resolvedFilePath.slice(resolvedCollectionPath.length);
+    if (relativePath.startsWith("/")) {
+      relativePath = relativePath.slice(1);
+    }
+    return relativePath;
+  }
+
+  function resolve(filePath: string) {
+    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,
+    };
+  }
+
+  function deleted(filePath: string) {
+    const resolved = resolve(filePath);
+    if (!resolved) {
+      return false;
+    }
+
+    const { collection, relativePath } = resolved;
+
+    const index = collection.files.findIndex(
+      (file) => file.path === relativePath
+    );
+    const deleted = collection.files.splice(index, 1);
+
+    return deleted.length > 0;
+  }
+
+  async function changed(filePath: string) {
+    const resolved = resolve(filePath);
+    if (!resolved) {
+      return false;
+    }
+
+    const { collection, relativePath } = resolved;
+    const index = collection.files.findIndex(
+      (file) => file.path === relativePath
+    );
+
+    const file = await readCollectionFile(
+      path.join(baseDirectory, collection.directory),
+      relativePath
+    );
+
+    if (!file) {
+      return false;
+    }
+
+    if (index === -1) {
+      collection.files.push(file);
+    } else {
+      collection.files[index] = file;
+    }
+
+    return true;
+  }
+
+  return {
+    deleted,
+    changed,
+  };
+}
+
+export type Synchronizer = ReturnType<typeof createSynchronizer>;