Editor

examples/content/markdown/authors/tony.md

@@ -10,9 +10,10 @@ friend: 40s3
 image: tony.svg
 date_joined: 2021-02-25T16:41:59.558Z
 skills:
-  sitting: 204
+  sitting: 69
   breathing: 7.07
-  liquid_consumption: 100
+  liquid_consumption: 420
   existence: simulation
   sports: -2
 ---
+

examples/nextjs/flatbread.config.ts

@@ -19,21 +19,21 @@ export default defineConfig({
   content: [
     {
       path: 'content/markdown/posts',
-      collection: 'Post',
+      name: 'Post',
       refs: {
         authors: 'Author',
       },
     },
     {
       path: 'content/markdown/posts/[category]/[slug].md',
-      collection: 'PostCategory',
+      name: 'PostCategory',
       refs: {
         authors: 'Author',
       },
     },
     {
       path: 'content/markdown/posts/**/*.md',
-      collection: 'PostCategoryBlob',
+      name: 'PostCategoryBlob',
       refs: {
         authors: 'Author',
       },

examples/sveltekit/flatbread.config.js

@@ -16,58 +16,66 @@ const transformerConfig = {
 export default defineConfig({
   source: sourceFilesystem(),
   transformer: [transformerMarkdown(transformerConfig), transformerYaml()],
+
+  collectionResolvers: [
+    function fakeResolver(schemaComposer, args) {
+      const { name } = args;
+
+      schemaComposer.Query.addFields({
+        [`fake${name}`]: {
+          type: 'String',
+          description: `fake resolver`,
+          resolve() {
+            return `fake ${name}!`;
+          },
+        },
+      });
+    },
+  ],
+
   content: [
     {
       path: 'content/markdown/posts',
-      collection: 'Post',
+      name: 'Post',
       refs: {
         authors: 'Author',
       },
     },
     {
       path: 'content/markdown/posts/[category]/[slug].md',
-      collection: 'PostCategory',
-      refs: {
-        authors: 'Author',
-      },
-    },
-    {
-      path: 'content/markdown/posts/**/*.md',
-      collection: 'PostCategoryBlob',
+      name: 'PostCategory',
       refs: {
         authors: 'Author',
       },
     },
     {
       path: 'content/markdown/authors',
-      collection: 'Author',
+      name: 'Author',
       refs: {
         friend: 'Author',
       },
       overrides: [
         createSvImgField('image', {
           inputDir: 'static/authorImages',
           outputDir: 'static/g',
-          srcGenerator: (path) => '/g/' + path,
+          srcGenerator: (path) => 'http://localhost:5174/g/' + path,
         }),
       ],
     },
     {
       path: 'content/yaml/authors',
-      collection: 'YamlAuthor',
+      name: 'YamlAuthor',
       refs: {
         friend: 'YamlAuthor',
       },
     },
     {
       path: 'content/markdown/deeply-nested',
-      collection: 'OverrideTest',
+      name: 'OverrideTest',
       overrides: [
         {
           field: 'deeply.nested',
           type: 'String',
-          test: undefined,
-          test2: null,
           resolve: (source) => String(source).toUpperCase(),
         },
         {

examples/sveltekit/src/routes/index.svelte

@@ -3,9 +3,13 @@
     const query = `
       query PostCategory {
         allPostCategories (sortBy: "title", order: DESC) {
-          _collection
-          _filename
-          _slug
+          _metadata {
+            sourceContext {
+              filename
+              slug
+            }
+            collection
+          }
           id
           title
           category
@@ -18,7 +22,11 @@
             timeToRead
           }
           authors {
-            _slug
+            _metadata {
+              sourceContext {
+                slug
+              }
+            }
             id
             name
             entity
@@ -99,9 +107,7 @@
 
 <div class="grid grid-cols-2 divide-x-2 divide-black">
   <Pane label="JSON Output">
-    <pre
-      class="overflow-auto p-3"
-      style="height: calc(100vh - 3.5rem);">
+    <pre class="overflow-auto p-3" style="height: calc(100vh - 3.5rem);">
       <code class="text-sm">
         {JSON.stringify(data, null, 2)}
       </code>

packages/core/package.json

@@ -35,6 +35,7 @@
     "lodash-es": "4.17.21",
     "lru-cache": "7.13.2",
     "matcher": "5.0.0",
+    "nanoid": "4.0.0",
     "plur": "5.1.0"
   },
   "devDependencies": {

packages/core/src/cache/cache.ts

@@ -1,8 +1,7 @@
 import { GraphQLSchema } from 'graphql';
 import LRU from 'lru-cache';
-import { createHash } from 'node:crypto';
 import { LoadedFlatbreadConfig } from '../types';
-import { anyToString } from '../utils/stringUtils';
+import createShaHash from '../utils/createShaHash';
 
 type SchemaCacheKey = string;
 
@@ -29,7 +28,7 @@ export function cacheSchema(
   config: LoadedFlatbreadConfig,
   schema: GraphQLSchema
 ) {
-  const schemaHashKey = getSchemaHash(config);
+  const schemaHashKey = createShaHash(config);
   cache.schema.set(schemaHashKey, schema);
 }
 
@@ -39,13 +38,6 @@ export function cacheSchema(
 export function checkCacheForSchema(
   config: LoadedFlatbreadConfig
 ): GraphQLSchema | undefined {
-  const schemaHashKey = getSchemaHash(config);
+  const schemaHashKey = createShaHash(config);
   return cache.schema.get(schemaHashKey);
 }
-
-/**
- * Generates a hash key for a given Flatbread config.
- */
-export function getSchemaHash(config: LoadedFlatbreadConfig) {
-  return createHash('md5').update(anyToString(config)).digest('hex');
-}

packages/core/src/generators/collectionMutations.ts

@@ -0,0 +1,105 @@
+import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+import { get, merge } from 'lodash-es';
+import { CollectionContext, CollectionResolverArgs, EntryNode } from '../types';
+
+export default function addCollectionMutations(
+  schemaComposer: SchemaComposer,
+  args: CollectionResolverArgs
+) {
+  const { name, objectTypeComposer, updateCollectionRecord, collectionEntry } =
+    args;
+
+  async function update(
+    payload: Record<string, EntryNode>,
+    existing: EntryNode
+  ) {
+    // remove _metadata to prevent injection
+    const { _metadata, ...update } = payload?.[name];
+
+    const targetRecord = objectTypeComposer
+      .getResolver('findById')
+      .resolve({ args: update });
+
+    // remove supplied key (might not be required)
+    delete update[targetRecord._metadata.referenceField];
+    const newRecord = merge(targetRecord, update);
+
+    await updateCollectionRecord(collectionEntry, newRecord);
+
+    return newRecord;
+  }
+
+  async function create(source: unknown, payload: Record<string, EntryNode>) {
+    collectionEntry.creationRequiredFields.forEach((field) => {
+      if (!payload[name].hasOwnProperty(field))
+        throw new Error(
+          `field ${field} is required when creating a new ${name}`
+        );
+    });
+
+    const record = merge(payload[name], {
+      _metadata: {
+        referenceField: collectionEntry.referenceField ?? 'id',
+        collection: name,
+        transformedBy: collectionEntry?.defaultTransformer,
+        sourcedBy: collectionEntry?.defaultSource,
+      } as CollectionContext,
+    });
+
+    return await updateCollectionRecord(collectionEntry, record);
+  }
+
+  schemaComposer.Mutation.addFields({
+    [`update${name}`]: {
+      type: objectTypeComposer,
+      args: {
+        [name]: objectTypeComposer
+          .getInputTypeComposer()
+          .makeFieldNonNull(collectionEntry.creationRequiredFields),
+      },
+      description: `Update a ${name}`,
+      async resolve(source: unknown, payload: Record<string, EntryNode>) {
+        const { _metadata, ...args } = payload?.[name];
+
+        const existingRecord = objectTypeComposer
+          .getResolver('findById')
+          .resolve({ args });
+
+        if (!existingRecord)
+          throw new Error(
+            `${name} with ${collectionEntry.referenceField} of ${get(
+              args,
+              collectionEntry.referenceField
+            )} not found`
+          );
+        return update(payload, existingRecord);
+      },
+    },
+    [`create${name}`]: {
+      type: objectTypeComposer,
+      args: {
+        [name]: objectTypeComposer
+          .getInputTypeComposer()
+          .clone(`${name}CreateInput`)
+          .removeField('id')
+          .makeFieldNonNull(collectionEntry.creationRequiredFields),
+      },
+      description: `Create a ${name}`,
+      resolve: create,
+    },
+    [`upsert${name}`]: {
+      type: objectTypeComposer,
+      args: { [name]: objectTypeComposer.getInputTypeComposer() },
+      async resolve(source: unknown, payload: Record<string, EntryNode>) {
+        const { _metadata, ...args } = payload?.[name];
+
+        const existingRecord = objectTypeComposer
+          .getResolver('findById')
+          .resolve({ args });
+
+        if (existingRecord) return update(payload, existingRecord);
+        create(source, payload);
+      },
+    },
+  });
+}

packages/core/src/generators/collectionQueries.ts

@@ -0,0 +1,82 @@
+import resolveQueryArgs from '../resolvers/arguments';
+
+import { SchemaComposer } from 'graphql-compose';
+import { cloneDeep } from 'lodash-es';
+import {
+  generateArgsForAllItemQuery,
+  generateArgsForManyItemQuery,
+  generateArgsForSingleItemQuery,
+} from '../generators/arguments';
+import { CollectionResolverArgs, EntryNode } from '../types';
+
+export default function addCollectionQueries(
+  schemaComposer: SchemaComposer,
+  args: CollectionResolverArgs & { allContentNodesJSON: Record<string, any[]> }
+) {
+  const { name, pluralName, config, objectTypeComposer, allContentNodesJSON } =
+    args;
+
+  const pluralTypeQueryName = 'all' + pluralName;
+
+  objectTypeComposer.addResolver({
+    name: 'findById',
+    type: () => objectTypeComposer,
+    description: `Find one ${name} by its ID`,
+    args: generateArgsForSingleItemQuery(),
+    resolve: (rp: Record<string, any>) =>
+      cloneDeep(
+        allContentNodesJSON[name].find(
+          (node: EntryNode) => node.id === rp.args.id
+        )
+      ),
+  });
+
+  objectTypeComposer.addResolver({
+    name: 'findMany',
+    type: () => [objectTypeComposer],
+    description: `Find many ${pluralName} by their IDs`,
+    args: generateArgsForManyItemQuery(pluralName),
+    resolve: (rp: Record<string, any>) => {
+      const idsToFind = rp.args.ids ?? [];
+      const matches =
+        cloneDeep(allContentNodesJSON[name])?.filter((node: EntryNode) =>
+          idsToFind?.includes(node.id)
+        ) ?? [];
+      return resolveQueryArgs(matches, rp.args, config, {
+        type: {
+          name: name,
+          pluralName: pluralName,
+          pluralQueryName: pluralTypeQueryName,
+        },
+      });
+    },
+  });
+
+  objectTypeComposer.addResolver({
+    name: 'all',
+    args: generateArgsForAllItemQuery(pluralName),
+    type: () => [objectTypeComposer],
+    description: `Return a set of ${pluralName}`,
+    resolve: (rp: Record<string, any>) => {
+      const nodes = cloneDeep(allContentNodesJSON[name]);
+      return resolveQueryArgs(nodes, rp.args, config, {
+        type: {
+          name: name,
+          pluralName: pluralName,
+          pluralQueryName: pluralTypeQueryName,
+        },
+      });
+    },
+  });
+
+  schemaComposer.Query.addFields({
+    /**
+     * Add find by ID to each content type
+     */
+    [name]: objectTypeComposer.getResolver('findById'),
+    /**
+     * Add find 'many' to each content type
+     */
+    [pluralTypeQueryName]: objectTypeComposer.getResolver('all'),
+  });
+}