nuxt-google-sheets-import 0.1.4

package/dist/runtime/composables/useGoogleSheetsImportWorkflow.js

@@ -0,0 +1,256 @@
+import { useRuntimeConfig } from "#imports";
+import { computed, reactive, ref, toValue, watch } from "vue";
+import { useGoogleSheetsImport } from "./useGoogleSheetsImport.js";
+export function useGoogleSheetsImportWorkflow(options = {}) {
+  const { getSheets, getValues, getCollectionType, writeFiles } = useGoogleSheetsImport();
+  const config = useRuntimeConfig();
+  const defaultContentDir = computed(
+    () => config.public.googleSheetsImport?.defaultContentDir ?? "content/data"
+  );
+  const sourceStatus = ref("idle");
+  const sourceError = ref("");
+  const sheetTitles = ref([]);
+  const source = reactive({
+    spreadsheetId: void 0,
+    sheetTitle: void 0,
+    range: void 0,
+    schema: void 0
+  });
+  const upperCaseRange = computed({
+    get: () => source.range,
+    set: (value) => {
+      source.range = value?.toUpperCase() || "";
+    }
+  });
+  const selectedSheetPreview = computed(
+    () => sheetTitles.value.find((sheet) => sheet.label === source.sheetTitle)
+  );
+  const sourceQuery = computed(() => {
+    if (!source.spreadsheetId || !source.sheetTitle || !source.range || !source.schema) {
+      return null;
+    }
+    return {
+      spreadsheetId: source.spreadsheetId,
+      sheetTitle: source.sheetTitle,
+      range: source.range,
+      schema: source.schema
+    };
+  });
+  const externalQuery = computed(() => {
+    if (!options.query) {
+      return null;
+    }
+    const value = toValue(options.query);
+    return value ?? null;
+  });
+  const activeQuery = computed(() => externalQuery.value ?? sourceQuery.value);
+  const canLoadValues = computed(() => Boolean(activeQuery.value));
+  const selectedCollectionType = ref("unknown");
+  const selectedCollectionTypeStatus = ref("idle");
+  async function refreshCollectionType() {
+    const schema = activeQuery.value?.schema?.trim();
+    if (!schema) {
+      selectedCollectionType.value = "unknown";
+      selectedCollectionTypeStatus.value = "idle";
+      return;
+    }
+    selectedCollectionTypeStatus.value = "pending";
+    try {
+      const resolved = await getCollectionType(schema);
+      selectedCollectionType.value = resolved.collectionType;
+      selectedCollectionTypeStatus.value = "success";
+    } catch {
+      selectedCollectionType.value = "unknown";
+      selectedCollectionTypeStatus.value = "error";
+    }
+  }
+  watch(() => activeQuery.value?.schema, async () => {
+    await refreshCollectionType();
+  }, { immediate: true });
+  async function loadSheetTitles(spreadsheetId) {
+    if (!spreadsheetId) {
+      return;
+    }
+    sourceStatus.value = "pending";
+    sourceError.value = "";
+    try {
+      sheetTitles.value = await getSheets(spreadsheetId);
+      sourceStatus.value = "success";
+    } catch (error) {
+      sourceStatus.value = "error";
+      sheetTitles.value = [];
+      sourceError.value = error instanceof Error ? error.message : "Failed to retrieve Google Sheet titles.";
+    }
+  }
+  watch(() => source.spreadsheetId, async (spreadsheetId, previousSpreadsheetId) => {
+    if (spreadsheetId !== previousSpreadsheetId) {
+      source.sheetTitle = void 0;
+      source.range = void 0;
+      source.schema = void 0;
+      await loadSheetTitles(spreadsheetId);
+    }
+  });
+  watch(() => source.sheetTitle, () => {
+    if (!source.range) {
+      source.range = sheetTitles.value.find((sheet) => sheet.label === source.sheetTitle)?.range;
+    }
+    if (source.sheetTitle && !source.schema) {
+      source.schema = source.sheetTitle.replace(/ /g, "_");
+    }
+  });
+  const status = ref("idle");
+  const writeStatus = ref("idle");
+  const importError = ref("");
+  const writeError = ref("");
+  const writeSummary = ref({
+    written: 0,
+    overwritten: 0,
+    skipped: 0
+  });
+  const values = ref([]);
+  const validationErrors = ref([]);
+  const logs = ref([]);
+  const writeFile = reactive({
+    folder: kebabize(activeQuery.value?.sheetTitle ?? source.sheetTitle ?? ""),
+    slug: void 0,
+    order: void 0,
+    outputFormat: "frontmatter",
+    overwriteMode: "overwrite"
+  });
+  const resolvedBaseContentDir = computed(() => {
+    if (selectedCollectionType.value === "page") {
+      return "content";
+    }
+    if (selectedCollectionType.value === "data") {
+      return "content/data";
+    }
+    return defaultContentDir.value;
+  });
+  const resolvedDestinationPath = computed(() => {
+    const folder = writeFile.folder?.trim();
+    return folder ? `${resolvedBaseContentDir.value}/${folder}` : resolvedBaseContentDir.value;
+  });
+  watch(activeQuery, (query) => {
+    if (query?.sheetTitle && !writeFile.folder) {
+      writeFile.folder = kebabize(query.sheetTitle);
+    }
+  }, { immediate: true });
+  const columnList = computed(() => {
+    const unique = /* @__PURE__ */ new Set();
+    for (const record of values.value) {
+      collectKeys(record).forEach((key) => unique.add(key));
+    }
+    return [...unique];
+  });
+  const productsLength = computed(() => values.value.length);
+  const logsLength = computed(() => logs.value.length);
+  const canWrite = computed(() => Boolean(values.value.length && writeFile.slug && writeFile.folder && writeStatus.value !== "pending"));
+  const previewRows = computed(() => values.value.slice(0, 5));
+  const shownValidationErrors = computed(() => validationErrors.value.slice(0, 20));
+  watch(columnList, (keys) => {
+    if (!keys.length) {
+      return;
+    }
+    if (!writeFile.slug) {
+      const slugCandidate = keys.find((key) => /(?:^|\.)(?:slug|id)$/i.test(key));
+      writeFile.slug = slugCandidate ?? keys[0];
+    }
+    if (!writeFile.order) {
+      const orderCandidate = keys.find((key) => /(?:^|\.)(?:order|pageOrder)$/i.test(key));
+      writeFile.order = orderCandidate;
+    }
+  }, { immediate: true });
+  async function loadValues(queryArg) {
+    const query = queryArg ?? activeQuery.value;
+    if (!query) {
+      return;
+    }
+    status.value = "pending";
+    validationErrors.value = [];
+    importError.value = "";
+    writeStatus.value = "idle";
+    writeError.value = "";
+    writeSummary.value = { written: 0, overwritten: 0, skipped: 0 };
+    logs.value = [];
+    try {
+      const response = await getValues(query);
+      values.value = response.records;
+      validationErrors.value = response.errors;
+      status.value = "success";
+    } catch (error) {
+      status.value = "error";
+      values.value = [];
+      importError.value = error instanceof Error ? error.message : "Could not load values from Google Sheets.";
+    }
+  }
+  async function writeValues() {
+    if (!canWrite.value || !writeFile.slug || !writeFile.folder) {
+      return;
+    }
+    writeStatus.value = "pending";
+    writeError.value = "";
+    try {
+      const response = await writeFiles({
+        records: values.value,
+        schema: activeQuery.value?.schema,
+        folder: writeFile.folder,
+        slugKey: writeFile.slug,
+        orderKey: writeFile.order,
+        outputFormat: writeFile.outputFormat,
+        overwriteMode: writeFile.overwriteMode
+      });
+      logs.value = response.logs;
+      writeSummary.value = response.summary;
+      writeStatus.value = "success";
+    } catch (error) {
+      writeStatus.value = "error";
+      writeError.value = error instanceof Error ? error.message : "Could not write files.";
+    }
+  }
+  return {
+    source,
+    sourceStatus,
+    sourceError,
+    sheetTitles,
+    upperCaseRange,
+    selectedSheetPreview,
+    sourceQuery,
+    activeQuery,
+    canLoadValues,
+    selectedCollectionType,
+    selectedCollectionTypeStatus,
+    resolvedBaseContentDir,
+    resolvedDestinationPath,
+    loadSheetTitles,
+    status,
+    writeStatus,
+    importError,
+    writeError,
+    writeSummary,
+    values,
+    validationErrors,
+    logs,
+    writeFile,
+    columnList,
+    productsLength,
+    logsLength,
+    canWrite,
+    previewRows,
+    shownValidationErrors,
+    loadValues,
+    writeValues
+  };
+}
+function kebabize(str) {
+  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? "-" : "") + $.toLowerCase());
+}
+function collectKeys(obj, prefix = "") {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return [];
+  }
+  return Object.entries(obj).flatMap(([key, value]) => {
+    const next = prefix ? `${prefix}.${key}` : key;
+    const nested = collectKeys(value, next);
+    return nested.length ? nested : [next];
+  });
+}

package/dist/runtime/import/schemas.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const machinesSmoke: z.ZodObject<{
+    pageOrder: z.ZodNumber;
+    modelId: z.ZodString;
+    machineName: z.ZodString;
+    cutRate: z.ZodNumber;
+    featurePrimary: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const example: z.ZodObject<{
+    slug: z.ZodString;
+    pageOrder: z.ZodCoercedNumber<unknown>;
+    number: z.ZodCoercedNumber<unknown>;
+    string: z.ZodString;
+    enumString: z.ZodEnum<{
+        foo: "foo";
+        bar: "bar";
+        baz: "baz";
+    }>;
+    literalString: z.ZodLiteral<"foo">;
+    unionString: z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
+    unionStringArray: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>>;
+    exclusiveUnionString: z.ZodXor<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
+    stringArray: z.ZodArray<z.ZodString>;
+    boolean: z.ZodCoercedBoolean<unknown>;
+    object: z.ZodObject<{
+        key1: z.ZodString;
+        key2: z.ZodString;
+    }, z.core.$strip>;
+    objectArray: z.ZodArray<z.ZodObject<{
+        keyA: z.ZodString;
+        keyB: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const schemas: {
+    machinesSmoke: z.ZodObject<{
+        pageOrder: z.ZodNumber;
+        modelId: z.ZodString;
+        machineName: z.ZodString;
+        cutRate: z.ZodNumber;
+        featurePrimary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    example: z.ZodObject<{
+        slug: z.ZodString;
+        pageOrder: z.ZodCoercedNumber<unknown>;
+        number: z.ZodCoercedNumber<unknown>;
+        string: z.ZodString;
+        enumString: z.ZodEnum<{
+            foo: "foo";
+            bar: "bar";
+            baz: "baz";
+        }>;
+        literalString: z.ZodLiteral<"foo">;
+        unionString: z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
+        unionStringArray: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>>;
+        exclusiveUnionString: z.ZodXor<readonly [z.ZodLiteral<"foo">, z.ZodLiteral<"bar">]>;
+        stringArray: z.ZodArray<z.ZodString>;
+        boolean: z.ZodCoercedBoolean<unknown>;
+        object: z.ZodObject<{
+            key1: z.ZodString;
+            key2: z.ZodString;
+        }, z.core.$strip>;
+        objectArray: z.ZodArray<z.ZodObject<{
+            keyA: z.ZodString;
+            keyB: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};

package/dist/runtime/import/schemas.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export const machinesSmoke = z.object({
+  pageOrder: z.number(),
+  modelId: z.string().min(1),
+  machineName: z.string().min(1),
+  cutRate: z.number(),
+  featurePrimary: z.string().optional()
+});
+export const example = z.object({
+  slug: z.string().min(1).max(100),
+  pageOrder: z.coerce.number().int(),
+  number: z.coerce.number(),
+  string: z.string().min(1).max(100),
+  enumString: z.enum(["foo", "bar", "baz"]),
+  literalString: z.literal("foo"),
+  unionString: z.union([z.literal("foo"), z.literal("bar")]),
+  unionStringArray: z.union([z.literal("foo"), z.literal("bar")]).array(),
+  exclusiveUnionString: z.xor([z.literal("foo"), z.literal("bar")]),
+  stringArray: z.string().array(),
+  boolean: z.coerce.boolean(),
+  object: z.object({
+    key1: z.string().min(1),
+    key2: z.string().min(1)
+  }),
+  objectArray: z.array(
+    z.object({
+      keyA: z.string().min(1),
+      keyB: z.string().min(1)
+    })
+  )
+});
+export const schemas = {
+  machinesSmoke,
+  example
+};

package/dist/runtime/pages/google-sheets-import.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/pages/google-sheets-import.vue

@@ -0,0 +1,14 @@
+<script setup>
+import { ref } from "vue";
+const sheetsList = ref([
+  { id: "1NKS0cTX6u5urtgQ3Q4Z2motiR2-9JmyPxcd05yVc1bc", label: "Metzner" },
+  { id: "1tGZCEoiikXfg3mOpfVWWTS1SSSsj18xv6Z3owrnnt4s", label: "Example Sheet" }
+]);
+</script>
+
+<template>
+  <UContainer>
+    <GoogleSheetsImportSchemaGuide />
+    <GoogleSheetsImportSource :google-sheets="sheetsList" />
+  </UContainer>
+</template>

package/dist/runtime/pages/google-sheets-import.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/server/api/collection-type.get.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    schema: string | null;
+    collectionType: "unknown" | ("page" | "data");
+    baseContentDir: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/collection-type.get.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { resolveCollectionTypeBySchema } from "../utils/collectionType.js";
+import { defineEventHandler, getValidatedQuery } from "h3";
+import { useRuntimeConfig } from "#imports";
+const querySchema = z.object({
+  schema: z.string().optional()
+});
+export default defineEventHandler(async (event) => {
+  const { schema } = await getValidatedQuery(event, (query) => querySchema.parse(query));
+  const config = useRuntimeConfig(event);
+  const moduleConfig = config.googleSheetsImport;
+  const fromConfig = moduleConfig.collectionTypeBySchema ?? {};
+  const collectionType = await resolveCollectionTypeBySchema(schema, fromConfig);
+  const baseContentDir = collectionType === "page" ? "content" : collectionType === "data" ? "content/data" : moduleConfig.defaultContentDir;
+  return {
+    schema: schema ?? null,
+    collectionType,
+    baseContentDir
+  };
+});

package/dist/runtime/server/api/schema-columns.get.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    schema: null;
+    schemas: string[];
+    columns: never[];
+    collectionType: string;
+    pageOverrideColumns: never[];
+} | {
+    schema: string;
+    schemas: string[];
+    columns: string[];
+    collectionType: "unknown" | ("page" | "data");
+    pageOverrideColumns: string[];
+}>>;
+export default _default;

package/dist/runtime/server/api/schema-columns.get.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { resolveCollectionTypeBySchema } from "../utils/collectionType.js";
+import { getSchemaColumns, PAGE_SCHEMA_OVERRIDE_COLUMNS } from "../utils/schemaColumns.js";
+import { getValidatedQuery, defineEventHandler, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+const querySchema = z.object({
+  schema: z.string().optional()
+});
+export default defineEventHandler(async (event) => {
+  const { schema } = await getValidatedQuery(event, (query) => querySchema.parse(query));
+  const config = useRuntimeConfig(event);
+  const moduleConfig = config.googleSheetsImport;
+  const schemaMap = {};
+  const availableSchemas = Object.keys(schemaMap).sort((left, right) => left.localeCompare(right));
+  if (!schema) {
+    return {
+      schema: null,
+      schemas: availableSchemas,
+      columns: [],
+      collectionType: "unknown",
+      pageOverrideColumns: []
+    };
+  }
+  const collectionType = await resolveCollectionTypeBySchema(schema, moduleConfig.collectionTypeBySchema ?? {});
+  const selectedSchema = schemaMap[schema];
+  if (!selectedSchema) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `Unknown schema: ${schema}`
+    });
+  }
+  return {
+    schema,
+    schemas: availableSchemas,
+    columns: getSchemaColumns(selectedSchema),
+    collectionType,
+    pageOverrideColumns: collectionType === "page" ? PAGE_SCHEMA_OVERRIDE_COLUMNS : []
+  };
+});

package/dist/runtime/server/api/sheets.get.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    spreadsheetId: string;
+    sheets: {
+        label: string;
+        range: string;
+    }[];
+}>>;
+export default _default;

package/dist/runtime/server/api/sheets.get.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { columnCountToRange } from "../utils/googleSheets.js";
+import { getValidatedQuery, defineEventHandler, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+const querySchema = z.object({
+  spreadsheetId: z.string().length(44)
+});
+export default defineEventHandler(async (event) => {
+  const { googleSheetsImport } = useRuntimeConfig();
+  const apiKey = googleSheetsImport?.googleApiKeyRuntimeKey;
+  const { spreadsheetId } = await getValidatedQuery(event, (query) => querySchema.parse(query));
+  if (!apiKey || typeof apiKey !== "string") {
+    throw createError({ statusCode: 500, statusMessage: `Missing Google API key in nuxt.config googleSheetsImport: { googleApiKeyRuntimeKey: '${apiKey}' }` });
+  }
+  const response = await $fetch(`https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}?key=${apiKey}`);
+  return {
+    spreadsheetId,
+    sheets: (response.sheets ?? []).map((sheet) => {
+      const columnCount = sheet.properties?.gridProperties?.columnCount ?? 1;
+      return {
+        label: sheet.properties?.title ?? "",
+        range: columnCountToRange(columnCount)
+      };
+    }).filter((sheet) => sheet.label)
+  };
+});

package/dist/runtime/server/api/values.post.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    headers: string[];
+    records: Record<string, unknown>[];
+    errors: string[];
+}>>;
+export default _default;

package/dist/runtime/server/api/values.post.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { transformAndValidateRows } from "../utils/transform.js";
+import { readBody, defineEventHandler, createError } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { schemas } from "../../import/schemas.js";
+const bodySchema = z.object({
+  spreadsheetId: z.string().length(44),
+  sheetTitle: z.string().min(1),
+  range: z.string().min(1),
+  schema: z.string().min(1)
+});
+export default defineEventHandler(async (event) => {
+  const body = bodySchema.parse(await readBody(event));
+  const { googleSheetsImport } = useRuntimeConfig();
+  const apiKey = googleSheetsImport?.googleApiKeyRuntimeKey;
+  if (!apiKey || typeof apiKey !== "string") {
+    throw createError({ statusCode: 500, statusMessage: `Missing Google API key in nuxt.config googleSheetsImport: { googleApiKeyRuntimeKey: '${apiKey}' }` });
+  }
+  const encodedRange = encodeURIComponent(`${body.sheetTitle}!${body.range}`);
+  const googleResponse = await $fetch(`https://sheets.googleapis.com/v4/spreadsheets/${body.spreadsheetId}/values/${encodedRange}?key=${apiKey}`);
+  const values = googleResponse.values ?? [];
+  const schemaMap = schemas;
+  const schema = schemaMap[body.schema];
+  if (!schema) {
+    throw createError({ statusCode: 400, statusMessage: `Unknown schema: ${body.schema}` });
+  }
+  const transformed = transformAndValidateRows(values, schema);
+  return {
+    headers: values[0] ?? [],
+    records: transformed.records,
+    errors: transformed.errors
+  };
+});

package/dist/runtime/server/api/write.post.d.ts

@@ -0,0 +1,11 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    count: number;
+    logs: string[];
+    contentDir: string;
+    summary: {
+        written: number;
+        overwritten: number;
+        skipped: number;
+    };
+}>>;
+export default _default;

package/dist/runtime/server/api/write.post.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { writeRecordAsFrontmatter } from "../utils/writeFrontmatter.js";
+import { resolveCollectionTypeBySchema } from "../utils/collectionType.js";
+import { defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+const bodySchema = z.object({
+  records: z.array(z.record(z.string(), z.unknown())),
+  schema: z.string().optional(),
+  folder: z.string().min(1),
+  slugKey: z.string().min(1),
+  orderKey: z.string().optional(),
+  contentDir: z.string().optional(),
+  outputFormat: z.enum(["frontmatter", "json", "yaml"]).optional().default("frontmatter"),
+  overwriteMode: z.enum(["skip", "overwrite", "overwrite-frontmatter"]).optional().default("overwrite")
+});
+function resolveContentDirByCollectionType(collectionType, schemaKey, fallback) {
+  if (collectionType === "page") {
+    return "content";
+  }
+  if (collectionType === "data") {
+    return "content/data";
+  }
+  if (!schemaKey) {
+    return fallback;
+  }
+  const normalizedSchemaKey = schemaKey.trim();
+  console.warn(
+    `[google-sheets-import] No collection type mapping found for schema "${normalizedSchemaKey}". Using fallback content directory "${fallback}". Add googleSheetsImport.collectionTypeBySchema["` + normalizedSchemaKey + '"] in nuxt.config.ts to route writes automatically.'
+  );
+  return fallback;
+}
+export default defineEventHandler(async (event) => {
+  const body = bodySchema.parse(await readBody(event));
+  const config = useRuntimeConfig(event);
+  const moduleConfig = config.googleSheetsImport;
+  const mappedInConfig = moduleConfig.collectionTypeBySchema ?? {};
+  const resolvedCollectionType = await resolveCollectionTypeBySchema(body.schema, mappedInConfig);
+  const resolvedContentDir = body.contentDir ?? resolveContentDirByCollectionType(resolvedCollectionType, body.schema, moduleConfig.defaultContentDir);
+  const logs = [];
+  const summary = {
+    written: 0,
+    overwritten: 0,
+    skipped: 0
+  };
+  for (const record of body.records) {
+    const result = await writeRecordAsFrontmatter({
+      record,
+      baseContentDir: resolvedContentDir,
+      folder: body.folder,
+      slugKey: body.slugKey,
+      orderKey: body.orderKey,
+      outputFormat: body.outputFormat,
+      overwriteMode: body.overwriteMode
+    });
+    logs.push(result.filePath);
+    summary[result.action]++;
+  }
+  return {
+    count: logs.length,
+    logs,
+    contentDir: resolvedContentDir,
+    summary
+  };
+});

package/dist/runtime/server/utils/collectionType.d.ts

@@ -0,0 +1,3 @@
+type CollectionType = 'page' | 'data';
+export declare function resolveCollectionTypeBySchema(schemaKey: string | undefined, collectionTypeBySchemaFromConfig: Record<string, CollectionType>): Promise<CollectionType | 'unknown'>;
+export {};