nuxt-google-sheets-import 0.1.4 → 0.1.6

package/README.md

@@ -29,17 +29,13 @@ export default defineNuxtConfig({
   googleSheetsImport: {
     apiBase: '/api/google-sheets-import',
     googleApiKeyRuntimeKey: 'googleApiKey',
-    schemaRegistryImport: '#imports',
-    schemaRegistryExport: 'schemas',
-    defaultContentDir: 'content',
-    collectionTypeBySchema: {
-      machines: 'page',
-      materials: 'data'
-    }
+    defaultContentDir: 'content'
   }
 })
 ```
 
+Collection type (`page` vs `data`) is derived from your Nuxt Content `content.config.ts` collection definitions.
+
 ## Environment
 
 ```bash
@@ -126,6 +122,7 @@ Benefits:
 
 - Reduces import failures by giving editors exact header names before filling a sheet
 - Supports nested/array header patterns used by schema mapping (for example `items[0].name`)
+- Uses a single column for arrays of scalar values (for example `tags` with `foo, bar, baz`)
 - For `page` collections, shows Nuxt Content built-in page override fields and allows copying them separately
 - Supports two copy modes:
   - line-by-line copy
@@ -135,14 +132,23 @@ Optional prop:
 
 - `initialSchema?: string`
 
-## Schema registry
+### Suggested Cell Examples
+
+Use these value patterns when filling sheets:
+
+- `string`: `example text`
+- `number`: `123`
+- `boolean`: `true` or `false`
+- `enum` / `literal`: use one of the schema's allowed values
+- `date-like string`: `2026-01-01`
+- `string[]` (scalar array): `foo, bar, baz` in a single cell
+- `object[]` (array of objects): use indexed headers like `items[0].name`, `items[0].price`
 
-The module resolves Zod schemas from a configurable module import so it does not depend on app-specific paths.
+## Schema source
 
-- `schemaRegistryImport` (default: `#imports`)
-- `schemaRegistryExport` (default: `schemas`)
+The module resolves Zod schemas from Nuxt auto-imports using `#imports.schemas`.
 
-Expected shape:
+Define a `schemas` export in `~/utils/googleSheetImportSchemas.ts`:
 
 ```ts
 export const schemas = {
@@ -151,23 +157,11 @@ export const schemas = {
 }
 ```
 
-If your schemas are exported from a custom file, point the module to it:
-
-```ts
-export default defineNuxtConfig({
-  modules: ['@tribeweb/nuxt-google-sheets-import'],
-  googleSheetsImport: {
-    schemaRegistryImport: '~/server/google-sheets/schemas',
-    schemaRegistryExport: 'schemas'
-  }
-})
-```
-
 ## Playground smoke test (`values` + `write`)
 
 The playground includes:
 
-- `playground/server/google-sheets/schemas.ts` (tiny local schema registry)
+- `playground/utils/googleSheetImportSchemas.ts` (tiny local schema registry)
 - `POST /api/google-sheets-import/values-smoke` (local transform/validation payload)
 - `playground/scripts/smoke.mjs` (calls `values-smoke`, then module `write` for `frontmatter`, `json`, `yaml`)
 

package/dist/module.d.mts

@@ -4,7 +4,6 @@ interface ModuleOptions {
     apiBase: string;
     googleApiKeyRuntimeKey: string;
     defaultContentDir: string;
-    collectionTypeBySchema: Record<string, 'page' | 'data'>;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-google-sheets-import",
   "configKey": "googleSheetsImport",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, extendPages, addServerHandler, addImportsDir, addComponentsDir, addImports } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, extendPages, addServerHandler, addImportsDir, addComponentsDir, addImports, addServerImports } from '@nuxt/kit';
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -13,32 +13,20 @@ const module$1 = defineNuxtModule({
   defaults: {
     apiBase: "/api/google-sheets-import",
     googleApiKeyRuntimeKey: "googleApiKey",
-    defaultContentDir: "content/data",
-    collectionTypeBySchema: {}
-    // schemaRegistryImport: '#imports',
-    // schemaRegistryExport: 'schemas',
+    defaultContentDir: "content/data"
   },
   setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
-    const normalizedCollectionTypeBySchema = Object.entries(options.collectionTypeBySchema).reduce((acc, [key, value]) => {
-      const trimmed = key.trim();
-      acc[trimmed] = value;
-      acc[trimmed.toLowerCase()] = value;
-      acc[trimmed.replace(/[-\s]+/g, "_").toLowerCase()] = value;
-      return acc;
-    }, {});
     nuxt.options.runtimeConfig.googleSheetsImport = {
+      ...nuxt.options.runtimeConfig.googleSheetsImport,
       apiBase: options.apiBase,
       googleApiKeyRuntimeKey: options.googleApiKeyRuntimeKey,
-      defaultContentDir: options.defaultContentDir,
-      collectionTypeBySchema: normalizedCollectionTypeBySchema
-      // schemaRegistryImport: options.schemaRegistryImport,
-      // schemaRegistryExport: options.schemaRegistryExport,
+      defaultContentDir: options.defaultContentDir
     };
     nuxt.options.runtimeConfig.public.googleSheetsImport = {
+      ...nuxt.options.runtimeConfig.public.googleSheetsImport,
       apiBase: options.apiBase,
-      defaultContentDir: options.defaultContentDir,
-      collectionTypeBySchema: normalizedCollectionTypeBySchema
+      defaultContentDir: options.defaultContentDir
     };
     nuxt.options.css.push(resolver.resolve("./runtime/assets/css/main.css"));
     extendPages((pages) => {
@@ -78,6 +66,11 @@ const module$1 = defineNuxtModule({
       path: resolver.resolve("./runtime/components")
     });
     addImports([
+      {
+        from: "~/utils/googleSheetImportSchemas",
+        name: "schemas",
+        as: "googleSheetsImportSchemas"
+      },
       {
         from: resolver.resolve("./runtime/types/googleSheetsApi"),
         name: "GoogleSheetsApiValues",
@@ -109,6 +102,13 @@ const module$1 = defineNuxtModule({
         type: true
       }
     ]);
+    addServerImports([
+      {
+        from: "~/utils/googleSheetImportSchemas",
+        name: "schemas",
+        as: "googleSheetsImportSchemas"
+      }
+    ]);
   }
 });
 

package/dist/runtime/components/GoogleSheetsImportExecute.vue

@@ -1,4 +1,7 @@
 <script setup>
+import { useGoogleSheetsImportWorkflow } from "../composables/useGoogleSheetsImportWorkflow";
+import { useToast } from "#imports";
+import { computed } from "vue";
 const props = defineProps({
   query: { type: Object, required: true }
 });

package/dist/runtime/components/GoogleSheetsImportSchemaGuide.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { computed, onMounted, ref, watch } from "vue";
+import { useToast } from "#imports";
 import { useGoogleSheetsImport } from "../composables/useGoogleSheetsImport";
 const props = defineProps({
   initialSchema: { type: String, required: false, default: "" }

package/dist/runtime/components/GoogleSheetsImportSource.vue

@@ -1,5 +1,8 @@
 <script setup>
 import { z } from "zod";
+import { useGoogleSheetsImportWorkflow } from "../composables/useGoogleSheetsImportWorkflow";
+import { useToast } from "#imports";
+import { watch } from "vue";
 const { googleSheets } = defineProps({
   googleSheets: { type: Array, required: true }
 });

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

@@ -9,8 +9,7 @@ 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 collectionType = await resolveCollectionTypeBySchema(schema);
   const baseContentDir = collectionType === "page" ? "content" : collectionType === "data" ? "content/data" : moduleConfig.defaultContentDir;
   return {
     schema: schema ?? null,

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

@@ -2,15 +2,13 @@ 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";
+import { googleSheetsImportSchemas } 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 schemaMap = googleSheetsImportSchemas ?? {};
   const availableSchemas = Object.keys(schemaMap).sort((left, right) => left.localeCompare(right));
   if (!schema) {
     return {
@@ -21,7 +19,7 @@ export default defineEventHandler(async (event) => {
       pageOverrideColumns: []
     };
   }
-  const collectionType = await resolveCollectionTypeBySchema(schema, moduleConfig.collectionTypeBySchema ?? {});
+  const collectionType = await resolveCollectionTypeBySchema(schema);
   const selectedSchema = schemaMap[schema];
   if (!selectedSchema) {
     throw createError({
@@ -29,10 +27,11 @@ export default defineEventHandler(async (event) => {
       statusMessage: `Unknown schema: ${schema}`
     });
   }
+  const columns = getSchemaColumns(selectedSchema);
   return {
     schema,
     schemas: availableSchemas,
-    columns: getSchemaColumns(selectedSchema),
+    columns,
     collectionType,
     pageOverrideColumns: collectionType === "page" ? PAGE_SCHEMA_OVERRIDE_COLUMNS : []
   };

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

@@ -1,8 +1,7 @@
 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";
+import { useRuntimeConfig, googleSheetsImportSchemas } from "#imports";
 const bodySchema = z.object({
   spreadsheetId: z.string().length(44),
   sheetTitle: z.string().min(1),
@@ -19,7 +18,7 @@ export default defineEventHandler(async (event) => {
   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 schemaMap = googleSheetsImportSchemas ?? {};
   const schema = schemaMap[body.schema];
   if (!schema) {
     throw createError({ statusCode: 400, statusMessage: `Unknown schema: ${body.schema}` });

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

@@ -25,7 +25,7 @@ function resolveContentDirByCollectionType(collectionType, schemaKey, 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.'
+    `[google-sheets-import] No collection type mapping found for schema "${normalizedSchemaKey}". Using fallback content directory "${fallback}". Ensure the matching Nuxt Content collection is defined with type "page" or "data" in content.config.ts.`
   );
   return fallback;
 }
@@ -33,8 +33,7 @@ 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 resolvedCollectionType = await resolveCollectionTypeBySchema(body.schema);
   const resolvedContentDir = body.contentDir ?? resolveContentDirByCollectionType(resolvedCollectionType, body.schema, moduleConfig.defaultContentDir);
   const logs = [];
   const summary = {

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

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

package/dist/runtime/server/utils/collectionType.js

@@ -12,46 +12,55 @@ function setCollectionType(map, key, type) {
     map[normalized] = type;
   }
 }
-async function readCollectionTypeBySchemaFromContentConfig() {
-  if (cachedCollectionTypeBySchema) {
-    return cachedCollectionTypeBySchema;
-  }
+function parseManifestSource(source) {
   const result = {};
-  try {
-    const contentConfigPath = path.resolve(process.cwd(), "content.config.ts");
-    const source = await readFile(contentConfigPath, "utf-8");
-    const collectionTypeMatches = source.matchAll(/(\w+)\s*:\s*defineCollection\([\s\S]{0,900}?type:\s*['"](page|data)['"]/g);
-    for (const match of collectionTypeMatches) {
-      const collectionName = match[1];
-      const collectionType = match[2];
-      if (collectionName) {
-        setCollectionType(result, collectionName, collectionType);
-      }
+  const schemas = /* @__PURE__ */ new Set();
+  const defaultExportIndex = source.indexOf("export default");
+  const manifestCollectionsSource = defaultExportIndex === -1 ? source : source.slice(defaultExportIndex);
+  const collectionTypeMatches = manifestCollectionsSource.matchAll(/"([^"\n]+)"\s*:\s*\{[\s\S]{0,500}?"type"\s*:\s*"(page|data)"/g);
+  for (const match of collectionTypeMatches) {
+    const collectionName = match[1];
+    const collectionType = match[2];
+    if (collectionName) {
+      schemas.add(collectionName);
+      setCollectionType(result, collectionName, collectionType);
     }
-    const schemaTypeMatches = source.matchAll(/type:\s*['"](page|data)['"][\s\S]{0,900}?schema:\s*schemas\.(\w+)/g);
-    for (const match of schemaTypeMatches) {
-      const collectionType = match[1];
-      const schemaKey = match[2];
-      if (schemaKey) {
-        setCollectionType(result, schemaKey, collectionType);
-      }
+  }
+  return {
+    collectionTypeBySchema: result,
+    schemas: Array.from(schemas).sort((left, right) => left.localeCompare(right))
+  };
+}
+async function readManifestData() {
+  const candidates = [
+    path.resolve(process.cwd(), ".nuxt/content/manifest.ts"),
+    path.resolve(process.cwd(), ".nuxt/content/manifest.mjs")
+  ];
+  for (const manifestPath of candidates) {
+    try {
+      const source = await readFile(manifestPath, "utf-8");
+      return parseManifestSource(source);
+    } catch {
     }
-  } catch {
-    cachedCollectionTypeBySchema = {};
+  }
+  return {
+    collectionTypeBySchema: {},
+    schemas: []
+  };
+}
+async function readCollectionTypeBySchema() {
+  if (cachedCollectionTypeBySchema) {
     return cachedCollectionTypeBySchema;
   }
-  cachedCollectionTypeBySchema = result;
+  const fromManifest = await readManifestData();
+  cachedCollectionTypeBySchema = fromManifest.collectionTypeBySchema;
   return cachedCollectionTypeBySchema;
 }
-export async function resolveCollectionTypeBySchema(schemaKey, collectionTypeBySchemaFromConfig) {
+export async function resolveCollectionTypeBySchema(schemaKey) {
   if (!schemaKey) {
     return "unknown";
   }
-  const mappedInContentConfig = await readCollectionTypeBySchemaFromContentConfig();
-  const map = {
-    ...mappedInContentConfig,
-    ...collectionTypeBySchemaFromConfig
-  };
+  const map = await readCollectionTypeBySchema();
   const normalizedSchemaKey = schemaKey.trim();
   const collectionType = normalizeSchemaKey(normalizedSchemaKey).map((key) => map[key]).find((value) => value === "page" || value === "data");
   return collectionType ?? "unknown";

package/dist/runtime/server/utils/schemaColumns.js

@@ -66,8 +66,11 @@ function collectSchemaColumns(schema, prefix = "") {
     const arrayPrefix = `${prefix}[0]`;
     const elementCandidate = getDefValue(unwrapped, "element");
     const arrayElement = isZodType(elementCandidate) ? elementCandidate : null;
-    const nested = arrayElement ? collectSchemaColumns(arrayElement, arrayPrefix) : [];
-    return nested.length ? nested : [arrayPrefix];
+    if (arrayElement && getObjectShape(arrayElement)) {
+      const nested = collectSchemaColumns(arrayElement, arrayPrefix);
+      return nested.length ? nested : [arrayPrefix];
+    }
+    return prefix ? [prefix] : [arrayPrefix];
   }
   const objectShape = getObjectShape(unwrapped);
   if (objectShape) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-google-sheets-import",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Schema-driven Google Sheets import module for Nuxt Content",
   "repository": "tribeweb/nuxt-google-sheets-import",
   "license": "MIT",

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

@@ -1,67 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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
-};