@content-collections/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,416 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  applyConfig: () => applyConfig,
+  build: () => build2,
+  createRunner: () => createRunner,
+  defineCollection: () => defineCollection,
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(src_exports);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/applyConfig.ts
+var esbuild = __toESM(require("esbuild"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// package.json
+var package_default = {
+  name: "@mdx-collections/core",
+  version: "1.0.0",
+  type: "module",
+  main: "dist/index.cjs",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  types: "./dist/index.d.ts",
+  scripts: {
+    build: "tsup src/index.ts --format esm,cjs --dts -d dist",
+    typecheck: "tsc",
+    test: "vitest --run --coverage"
+  },
+  devDependencies: {
+    "@types/micromatch": "^4.0.6",
+    "@types/node": "^20.9.0",
+    "@types/pluralize": "^0.0.33",
+    "@vitest/coverage-v8": "^0.34.6",
+    tsup: "^7.2.0",
+    tsx: "^4.1.1",
+    typescript: "^5.3.2",
+    vitest: "^0.34.6"
+  },
+  dependencies: {
+    camelcase: "^8.0.0",
+    esbuild: "^0.19.5",
+    "fast-glob": "^3.3.2",
+    "gray-matter": "^4.0.3",
+    micromatch: "^4.0.5",
+    pluralize: "^8.0.0",
+    zod: "^3.22.4"
+  }
+};
+
+// src/applyConfig.ts
+var importPathPlugin = {
+  name: "import-path",
+  setup(build3) {
+    build3.onResolve({ filter: /^\@mdx-collections\/core$/ }, () => {
+      return { path: import_node_path.default.join(__dirname, "index.ts"), external: true };
+    });
+  }
+};
+function resolveCacheDir(config, options) {
+  if (options.cacheDir) {
+    return options.cacheDir;
+  }
+  return import_node_path.default.join(import_node_path.default.dirname(config), ".mdx-collections", "cache");
+}
+async function applyConfig(config, options = {
+  configName: "mdx-collection-config.mjs"
+}) {
+  const cacheDir = resolveCacheDir(config, options);
+  await import_promises.default.mkdir(cacheDir, { recursive: true });
+  const outfile = import_node_path.default.join(cacheDir, options.configName);
+  const plugins = [];
+  if (process.env.NODE_ENV === "test") {
+    plugins.push(importPathPlugin);
+  }
+  await esbuild.build({
+    entryPoints: [config],
+    external: [...Object.keys(package_default.dependencies), "@mdx-collections/*"],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    plugins,
+    outfile
+  });
+  const module2 = await import(`file://${import_node_path.default.resolve(outfile)}?x=${Date.now()}`);
+  return {
+    ...module2.default,
+    path: config,
+    generateTypes: true
+  };
+}
+
+// src/run.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_pluralize = __toESM(require("pluralize"), 1);
+
+// src/collect.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_promises2 = require("fs/promises");
+var import_path = __toESM(require("path"), 1);
+var import_micromatch = __toESM(require("micromatch"), 1);
+async function collectFile(directory, filePath) {
+  const file = await (0, import_promises2.readFile)(import_path.default.join(directory, filePath), "utf-8");
+  const { data, content: body } = (0, import_gray_matter.default)(file);
+  return {
+    data,
+    body,
+    path: filePath
+  };
+}
+async function resolveCollection(collection) {
+  const filePaths = await (0, import_fast_glob.default)(collection.include, {
+    cwd: collection.directory,
+    onlyFiles: true,
+    absolute: false
+  });
+  const promises = filePaths.map(
+    (filePath) => collectFile(collection.directory, filePath)
+  );
+  return {
+    ...collection,
+    files: await Promise.all(promises)
+  };
+}
+async function collect(unresolvedCollections) {
+  const promises = unresolvedCollections.map(
+    (collection) => resolveCollection(collection)
+  );
+  return await Promise.all(promises);
+}
+function createRelativePath(directory, filePath) {
+  if (!filePath.startsWith(directory)) {
+    throw new Error("Path is not in collection directory");
+  }
+  let relativePath = filePath.slice(directory.length);
+  if (relativePath.startsWith("/")) {
+    relativePath = relativePath.slice(1);
+  }
+  return relativePath;
+}
+function isIncluded(collection, path5) {
+  if (path5.startsWith(collection.directory)) {
+    const relativePath = createRelativePath(collection.directory, path5);
+    return import_micromatch.default.isMatch(relativePath, collection.include);
+  }
+  return false;
+}
+async function syncFile(collection, modification, path5) {
+  if ("added" === modification) {
+    const file = await collectFile(collection.directory, path5);
+    collection.files.push(file);
+  } else if ("changed" === modification) {
+    const file = await collectFile(collection.directory, path5);
+    const index = collection.files.findIndex((file2) => file2.path === path5);
+    collection.files[index] = file;
+  } else if ("removed" === modification) {
+    const index = collection.files.findIndex((file) => file.path === path5);
+    collection.files.splice(index, 1);
+  }
+}
+function sync(collection, modification, path5) {
+  const relativePath = createRelativePath(collection.directory, path5);
+  return syncFile(collection, modification, relativePath);
+}
+
+// src/transformer.ts
+var TransformError = class extends Error {
+  type;
+  constructor(type, message) {
+    super(message);
+    this.type = type;
+  }
+};
+var throwingErrorHandler = (error) => {
+  throw error;
+};
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+async function transform(untransformedCollections, errorHandler = throwingErrorHandler) {
+  async function parseFile(collection, file) {
+    const { data, body, path: path5 } = file;
+    let parsedData = await collection.schema.safeParseAsync(data);
+    if (!parsedData.success) {
+      errorHandler(new TransformError("Validation", parsedData.error.message));
+      return null;
+    }
+    const document = {
+      ...parsedData.data,
+      _meta: {
+        path: path5
+      }
+    };
+    return {
+      document,
+      content: body
+    };
+  }
+  async function parseCollection(collection) {
+    const promises2 = collection.files.map(
+      (file) => parseFile(collection, file)
+    );
+    return {
+      ...collection,
+      documents: (await Promise.all(promises2)).filter(isDefined)
+    };
+  }
+  function createContext(collections2, file) {
+    return {
+      content: async () => file.content,
+      documents: (collection) => {
+        const resolved = collections2.find((c) => c.name === collection.name);
+        if (!resolved) {
+          throw new TransformError(
+            "Configuration",
+            `Collection ${collection.name} not found, do you have registered it in your configuration?`
+          );
+        }
+        return resolved.documents.map((doc) => doc.document);
+      }
+    };
+  }
+  async function transformCollection(collections2, collection) {
+    if (collection.transform) {
+      const docs = [];
+      for (const doc of collection.documents) {
+        const context = createContext(collections2, doc);
+        try {
+          docs.push({
+            ...doc,
+            document: await collection.transform(context, doc.document)
+          });
+        } catch (error) {
+          if (error instanceof TransformError) {
+            errorHandler(error);
+          } else {
+            errorHandler(new TransformError("Transform", String(error)));
+          }
+        }
+      }
+      return docs;
+    }
+    return collection.documents;
+  }
+  const promises = untransformedCollections.map(
+    (collection) => parseCollection(collection)
+  );
+  const collections = await Promise.all(promises);
+  for (const collection of collections) {
+    collection.documents = await transformCollection(collections, collection);
+  }
+  return collections;
+}
+
+// src/run.ts
+function createArrayConstName(name) {
+  let suffix = name.charAt(0).toUpperCase() + name.slice(1);
+  return "all" + (0, import_pluralize.default)(suffix);
+}
+async function createDataFiles(collections, directory) {
+  for (const collection of collections) {
+    const dataPath = import_node_path2.default.join(
+      directory,
+      `${createArrayConstName(collection.name)}.json`
+    );
+    await import_promises3.default.writeFile(
+      dataPath,
+      JSON.stringify(
+        collection.documents.map((doc) => doc.document),
+        null,
+        2
+      )
+    );
+  }
+}
+async function createJavaScriptFile(configuration, directory) {
+  const collections = configuration.collections.map(
+    ({ name }) => createArrayConstName(name)
+  );
+  let content = "";
+  for (const name of collections) {
+    content += `import ${name} from "./${name}.json";
+`;
+  }
+  content += "\n";
+  content += "export { " + collections.join(", ") + " };\n";
+  await import_promises3.default.writeFile(import_node_path2.default.join(directory, "index.js"), content, "utf-8");
+}
+async function createTypeDefinitionFile(configuration, directory) {
+  const importPath = import_node_path2.default.relative(directory, configuration.path);
+  let content = `import mdxConfiguration from "${importPath}";
+import { GetTypeByName } from "@mdx-collections/core";
+`;
+  const collections = configuration.collections;
+  for (const collection of collections) {
+    content += `
+`;
+    content += `export type ${collection.typeName} = GetTypeByName<typeof mdxConfiguration, "${collection.name}">;
+`;
+    content += `export declare const ${createArrayConstName(
+      collection.name
+    )}: Array<${collection.typeName}>;
+`;
+  }
+  content += "\n";
+  content += "export {};\n";
+  await import_promises3.default.writeFile(import_node_path2.default.join(directory, "index.d.ts"), content, "utf-8");
+}
+async function createRunner(configuration, directory) {
+  await import_promises3.default.mkdir(directory, { recursive: true });
+  const resolved = await collect(configuration.collections);
+  await createJavaScriptFile(configuration, directory);
+  if (configuration.generateTypes) {
+    await createTypeDefinitionFile(configuration, directory);
+  }
+  async function run() {
+    const collections = await transform(resolved);
+    await createDataFiles(collections, directory);
+    for (const collection of collections) {
+      if (collection.onSuccess) {
+        await collection.onSuccess(
+          collection.documents.map((doc) => doc.document)
+        );
+      }
+    }
+  }
+  return {
+    run,
+    sync: async (event, path5) => {
+      for (const collection of resolved) {
+        if (isIncluded(collection, path5)) {
+          await sync(collection, event, path5);
+          await run();
+        }
+      }
+    }
+  };
+}
+
+// src/utils.ts
+var import_camelcase = __toESM(require("camelcase"), 1);
+var import_pluralize2 = __toESM(require("pluralize"), 1);
+function generateTypeName(name) {
+  const singularName = import_pluralize2.default.singular(name);
+  return (0, import_camelcase.default)(singularName, { pascalCase: true });
+}
+
+// src/config.ts
+function defineCollection(collection) {
+  let typeName = collection.typeName;
+  if (!typeName) {
+    typeName = generateTypeName(collection.name);
+  }
+  return {
+    ...collection,
+    typeName
+  };
+}
+function defineConfig(config) {
+  return config;
+}
+
+// src/index.ts
+async function build2(config) {
+  const configuration = await applyConfig(config);
+  const baseDirectory = import_path2.default.dirname(config);
+  const directory = import_path2.default.join(baseDirectory, ".mdx-collections", "generated");
+  const runner = await createRunner(configuration, directory);
+  await runner.run();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyConfig,
+  build,
+  createRunner,
+  defineCollection,
+  defineConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,59 @@
+import { ZodTypeAny, z } from 'zod';
+
+type Meta = {
+    path: string;
+};
+type Document<TSchema extends ZodTypeAny> = z.infer<TSchema> & {
+    _meta: Meta;
+};
+type Context = {
+    content(): Promise<string>;
+    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Document<TCollection["schema"]>>;
+};
+type TransformFn<TSchema extends ZodTypeAny> = ((context: Context, data: Document<TSchema>) => any) | undefined;
+type CollectionRequest<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument> = {
+    name: TName;
+    typeName?: string;
+    schema: TSchema;
+    transform?: TTransform;
+    directory: string;
+    include: string | string[];
+    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
+};
+type Collection<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument> = CollectionRequest<TSchema, TName, TTransform, TDocument> & {
+    typeName: string;
+};
+type AnyCollection = Collection<ZodTypeAny, any, any, any>;
+declare function defineCollection<TSchema extends ZodTypeAny, TName extends string, TTransform extends TransformFn<TSchema>, TDocument = [TTransform] extends [(...args: any) => any] ? Awaited<ReturnType<TTransform>> : Document<TSchema>>(collection: CollectionRequest<TSchema, TName, TTransform, TDocument>): Collection<TSchema, TName, TTransform, TDocument>;
+type Configuration<TCollections extends Array<AnyCollection>> = {
+    collections: TCollections;
+};
+type AnyConfiguration = Configuration<Array<AnyCollection>>;
+declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
+
+type InternalConfiguration = {
+    collections: Array<AnyCollection>;
+    path: string;
+    generateTypes?: boolean;
+};
+type Options = {
+    configName: string;
+    cacheDir?: string;
+};
+declare function applyConfig(config: string, options?: Options): Promise<InternalConfiguration>;
+
+type Modification = "added" | "changed" | "removed";
+type CollectionByName<TConfiguration extends AnyConfiguration> = {
+    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
+};
+type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<ZodTypeAny, any, any, infer TDocument> ? TDocument : never;
+type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
+
+declare function createRunner(configuration: InternalConfiguration, directory: string): Promise<{
+    run: () => Promise<void>;
+    sync: (event: Modification, path: string) => Promise<void>;
+}>;
+
+declare function build(config: string): Promise<void>;
+
+export { AnyCollection, AnyConfiguration, Collection, CollectionRequest, Configuration, Context, Document, GetTypeByName, Meta, Modification, applyConfig, build, createRunner, defineCollection, defineConfig };

package/dist/index.d.ts

@@ -0,0 +1,146 @@
+import { ZodRawShape, z, ZodObject, ZodTypeAny, ZodString } from 'zod';
+
+type Meta = {
+    filePath: string;
+    fileName: string;
+    directory: string;
+    path: string;
+    extension: string;
+};
+type WithContent = {
+    content: ZodString;
+};
+type AddContent<TShape extends ZodRawShape> = TShape extends {
+    content: ZodTypeAny;
+} ? TShape : TShape & WithContent;
+type Schema<TShape extends ZodRawShape> = z.infer<ZodObject<AddContent<TShape>>> & {
+    _meta: Meta;
+};
+type Context = {
+    documents<TCollection extends AnyCollection>(collection: TCollection): Array<Schema<TCollection["schema"]>>;
+};
+type Z = typeof z;
+type CollectionRequest<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = {
+    name: TName;
+    typeName?: string;
+    schema: (z: Z) => TShape;
+    transform?: (context: Context, data: TSchema) => TTransformResult;
+    directory: string;
+    include: string | string[];
+    onSuccess?: (documents: Array<TDocument>) => void | Promise<void>;
+};
+type Collection<TName extends string, TShape extends ZodRawShape, TSchema, TTransformResult, TDocument> = Omit<CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>, "schema"> & {
+    typeName: string;
+    schema: TShape;
+};
+type AnyCollection = Collection<any, ZodRawShape, any, any, any>;
+declare function defineCollection<TName extends string, TShape extends ZodRawShape, TSchema = Schema<TShape>, TTransformResult = never, TDocument = [TTransformResult] extends [never] ? Schema<TShape> : Awaited<TTransformResult>>(collection: CollectionRequest<TName, TShape, TSchema, TTransformResult, TDocument>): Collection<TName, TShape, TSchema, TTransformResult, TDocument>;
+type Configuration<TCollections extends Array<AnyCollection>> = {
+    collections: TCollections;
+};
+type AnyConfiguration = Configuration<Array<AnyCollection>>;
+declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
+
+type Modification = "create" | "update" | "delete";
+type CollectionFile = {
+    data: {
+        content: string;
+        [key: string]: unknown;
+    };
+    path: string;
+};
+type CollectionByName<TConfiguration extends AnyConfiguration> = {
+    [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection;
+};
+type GetDocument<TCollection extends AnyCollection> = TCollection extends Collection<any, ZodRawShape, any, any, infer TDocument> ? TDocument : never;
+type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection = CollectionByName<TConfiguration>[TName]> = TCollection extends AnyCollection ? GetDocument<TCollection> : never;
+
+type CollectorEvents = {
+    "collector:read-error": {
+        filePath: string;
+        error: CollectError;
+    };
+    "collector:parse-error": {
+        filePath: string;
+        error: CollectError;
+    };
+};
+type ErrorType$2 = "Parse" | "Read";
+declare class CollectError extends Error {
+    type: ErrorType$2;
+    constructor(type: ErrorType$2, message: string);
+}
+
+type TransformerEvents = {
+    "transformer:validation-error": {
+        collection: AnyCollection;
+        file: CollectionFile;
+        error: TransformError;
+    };
+    "transformer:error": {
+        collection: AnyCollection;
+        error: TransformError;
+    };
+};
+type ErrorType$1 = "Validation" | "Configuration" | "Transform";
+declare class TransformError extends Error {
+    type: ErrorType$1;
+    constructor(type: ErrorType$1, message: string);
+}
+
+type WatcherEvents = {
+    "watcher:file-changed": {
+        filePath: string;
+        modification: Modification;
+    };
+};
+
+type EventWithError = {
+    error: Error;
+};
+type SystemEvent = {
+    _event: string;
+};
+type ErrorEvent = EventWithError & SystemEvent;
+type Events = BuilderEvents & CollectorEvents & TransformerEvents & WatcherEvents;
+type SystemEvents = {
+    _error: ErrorEvent;
+    _all: SystemEvent;
+};
+
+type ErrorType = "Read" | "Compile";
+declare class ConfigurationError extends Error {
+    type: ErrorType;
+    constructor(type: ErrorType, message: string);
+}
+type Options$1 = {
+    configName: string;
+    cacheDir?: string;
+};
+
+type BuilderEvents = {
+    "builder:start": {
+        startedAt: number;
+    };
+    "builder:end": {
+        startedAt: number;
+        endedAt: number;
+    };
+};
+type Options = Options$1 & {
+    outputDir?: string;
+};
+declare function createBuilder(configurationPath: string, options?: Options): Promise<{
+    sync: (modification: Modification, filePath: string) => Promise<boolean>;
+    build: () => Promise<void>;
+    watch: () => Promise<{
+        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_1 extends "_error" | "_all">(key: TKey_1, listener: (event: SystemEvents[TKey_1]) => void): void;
+    };
+}>;
+type Builder = Awaited<ReturnType<typeof createBuilder>>;
+
+export { AnyCollection, AnyConfiguration, Builder, BuilderEvents, CollectError, Collection, CollectionRequest, Configuration, ConfigurationError, Context, GetTypeByName, Meta, Modification, Schema, TransformError, createBuilder, defineCollection, defineConfig };