nuxt-google-sheets-import 0.1.4

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

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+let cachedCollectionTypeBySchema = null;
+function normalizeSchemaKey(key) {
+  const trimmed = key.trim();
+  const lower = trimmed.toLowerCase();
+  const snake = trimmed.replace(/[-\s]+/g, "_").toLowerCase();
+  return Array.from(/* @__PURE__ */ new Set([trimmed, lower, snake]));
+}
+function setCollectionType(map, key, type) {
+  for (const normalized of normalizeSchemaKey(key)) {
+    map[normalized] = type;
+  }
+}
+async function readCollectionTypeBySchemaFromContentConfig() {
+  if (cachedCollectionTypeBySchema) {
+    return cachedCollectionTypeBySchema;
+  }
+  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 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);
+      }
+    }
+  } catch {
+    cachedCollectionTypeBySchema = {};
+    return cachedCollectionTypeBySchema;
+  }
+  cachedCollectionTypeBySchema = result;
+  return cachedCollectionTypeBySchema;
+}
+export async function resolveCollectionTypeBySchema(schemaKey, collectionTypeBySchemaFromConfig) {
+  if (!schemaKey) {
+    return "unknown";
+  }
+  const mappedInContentConfig = await readCollectionTypeBySchemaFromContentConfig();
+  const map = {
+    ...mappedInContentConfig,
+    ...collectionTypeBySchemaFromConfig
+  };
+  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/googleSheets.d.ts

@@ -0,0 +1 @@
+export declare function columnCountToRange(columnCount: number): string;

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

@@ -0,0 +1,10 @@
+export function columnCountToRange(columnCount) {
+  let dividend = columnCount;
+  let columnName = "";
+  while (dividend > 0) {
+    const modulo = (dividend - 1) % 26;
+    columnName = String.fromCharCode(65 + modulo) + columnName;
+    dividend = Math.floor((dividend - modulo) / 26);
+  }
+  return `A:${columnName}`;
+}

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const PAGE_SCHEMA_OVERRIDE_COLUMNS: string[];
+export declare function getSchemaColumns(schema: z.ZodTypeAny): string[];

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+export const PAGE_SCHEMA_OVERRIDE_COLUMNS = [
+  "path",
+  "title",
+  "description",
+  "seo.title",
+  "seo.description",
+  "seo.meta",
+  "seo.link",
+  "body.type",
+  "body.children",
+  "body.toc",
+  "navigation",
+  "navigation.title",
+  "navigation.description",
+  "navigation.icon"
+];
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value;
+}
+function getDefValue(schema, key) {
+  if (!schema || typeof schema !== "object") {
+    return void 0;
+  }
+  const def = schema._def;
+  if (!def || typeof def !== "object") {
+    return void 0;
+  }
+  return def[key];
+}
+function nextInnerSchema(schema) {
+  const candidate = getDefValue(schema, "innerType") ?? getDefValue(schema, "schema") ?? getDefValue(schema, "type") ?? getDefValue(schema, "in");
+  return isZodType(candidate) ? candidate : null;
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  for (let index = 0; index < 20; index++) {
+    const next = nextInnerSchema(current);
+    if (!next || next === current) {
+      break;
+    }
+    current = next;
+  }
+  return isZodType(current) ? current : null;
+}
+function getObjectShape(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!unwrapped || !(unwrapped instanceof z.ZodObject)) {
+    return null;
+  }
+  const maybeShape = unwrapped.shape;
+  if (typeof maybeShape === "function") {
+    return maybeShape();
+  }
+  if (maybeShape && typeof maybeShape === "object") {
+    return maybeShape;
+  }
+  return null;
+}
+function collectSchemaColumns(schema, prefix = "") {
+  const unwrapped = unwrapSchema(schema);
+  if (!unwrapped) {
+    return prefix ? [prefix] : [];
+  }
+  if (unwrapped instanceof z.ZodArray) {
+    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];
+  }
+  const objectShape = getObjectShape(unwrapped);
+  if (objectShape) {
+    return Object.entries(objectShape).flatMap(([key, childSchema]) => {
+      const childPrefix = prefix ? `${prefix}.${key}` : key;
+      return collectSchemaColumns(childSchema, childPrefix);
+    });
+  }
+  return prefix ? [prefix] : [];
+}
+export function getSchemaColumns(schema) {
+  const columns = collectSchemaColumns(schema);
+  return Array.from(new Set(columns)).sort((left, right) => left.localeCompare(right));
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare function transformAndValidateRows(values: string[][], schema: z.ZodTypeAny): {
+    records: Record<string, unknown>[];
+    errors: string[];
+};

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

@@ -0,0 +1,218 @@
+import { z } from "zod";
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value;
+}
+function getDefValue(schema, key) {
+  if (!schema || typeof schema !== "object") {
+    return void 0;
+  }
+  const def = schema._def;
+  if (!def || typeof def !== "object") {
+    return void 0;
+  }
+  return def[key];
+}
+function nextInnerSchema(schema) {
+  const candidate = getDefValue(schema, "innerType") ?? getDefValue(schema, "schema") ?? getDefValue(schema, "type") ?? getDefValue(schema, "in");
+  return isZodType(candidate) ? candidate : null;
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  for (let index = 0; index < 20; index++) {
+    const next = nextInnerSchema(current);
+    if (!next || next === current) {
+      break;
+    }
+    current = next;
+  }
+  return isZodType(current) ? current : null;
+}
+function hasWrapper(schema, wrapper) {
+  let current = schema;
+  for (let index = 0; index < 20; index++) {
+    if (!current) {
+      return false;
+    }
+    if (wrapper === "optional" && current instanceof z.ZodOptional) {
+      return true;
+    }
+    if (wrapper === "nullable" && current instanceof z.ZodNullable) {
+      return true;
+    }
+    const next = nextInnerSchema(current);
+    if (!next || next === current) {
+      return false;
+    }
+    current = next;
+  }
+  return false;
+}
+function parseHeaderPath(header) {
+  const tokens = [];
+  const parts = header.split(".");
+  for (const part of parts) {
+    const matches = part.matchAll(/([^[]+)|(\[(\d+)\])/g);
+    for (const match of matches) {
+      if (match[1]) {
+        tokens.push(match[1]);
+      }
+      if (match[3]) {
+        tokens.push(Number.parseInt(match[3], 10));
+      }
+    }
+  }
+  return tokens;
+}
+function setDeep(target, path, value) {
+  if (!path.length) {
+    return;
+  }
+  let cursor = target;
+  for (let index = 0; index < path.length; index++) {
+    const key = path[index];
+    if (key === void 0) {
+      return;
+    }
+    const isLast = index === path.length - 1;
+    const nextKey = path[index + 1];
+    if (isLast) {
+      cursor[key] = value;
+      return;
+    }
+    if (cursor[key] === void 0) {
+      cursor[key] = typeof nextKey === "number" ? [] : {};
+    }
+    const nextCursor = cursor[key];
+    if (!nextCursor || typeof nextCursor !== "object") {
+      return;
+    }
+    cursor = nextCursor;
+  }
+}
+function getObjectShape(schema) {
+  const unwrapped = unwrapSchema(schema);
+  if (!unwrapped) {
+    return null;
+  }
+  if (!(unwrapped instanceof z.ZodObject)) {
+    return null;
+  }
+  const maybeShape = unwrapped.shape;
+  if (typeof maybeShape === "function") {
+    const shape = maybeShape();
+    return shape;
+  }
+  if (maybeShape && typeof maybeShape === "object") {
+    return maybeShape;
+  }
+  return null;
+}
+function getSchemaAtPath(rootSchema, path) {
+  let current = rootSchema;
+  for (const segment of path) {
+    if (!current) {
+      return null;
+    }
+    const unwrapped = unwrapSchema(current);
+    if (!unwrapped) {
+      return null;
+    }
+    if (typeof segment === "number") {
+      const fallbackElement = getDefValue(unwrapped, "element");
+      const arrayElement = unwrapped instanceof z.ZodArray ? unwrapped.element : isZodType(fallbackElement) ? fallbackElement : null;
+      if (arrayElement) {
+        current = arrayElement;
+        continue;
+      }
+      return null;
+    }
+    const shape = getObjectShape(unwrapped);
+    if (!shape || !(segment in shape)) {
+      return null;
+    }
+    current = shape[segment] ?? null;
+  }
+  return current;
+}
+function toTypedCellValue(rawValue, schema) {
+  if (rawValue === void 0) {
+    return void 0;
+  }
+  const value = rawValue.trim();
+  const isOptional = hasWrapper(schema, "optional");
+  const isNullable = hasWrapper(schema, "nullable");
+  if (value === "") {
+    if (isOptional) {
+      return void 0;
+    }
+    if (isNullable) {
+      return null;
+    }
+  }
+  const unwrapped = schema ? unwrapSchema(schema) : null;
+  if (unwrapped instanceof z.ZodArray) {
+    if (value === "") {
+      return isOptional ? void 0 : isNullable ? null : [];
+    }
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+  }
+  if (unwrapped instanceof z.ZodBoolean) {
+    if (/^(?:true|1|yes)$/i.test(value)) {
+      return true;
+    }
+    if (/^(?:false|0|no)$/i.test(value)) {
+      return false;
+    }
+  }
+  if (unwrapped instanceof z.ZodNumber) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return value;
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return path ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+export function transformAndValidateRows(values, schema) {
+  if (!values?.length) {
+    return { records: [], errors: [] };
+  }
+  const headers = values[0] ?? [];
+  const rows = values.slice(1);
+  if (!headers.length) {
+    return { records: [], errors: [] };
+  }
+  const records = [];
+  const errors = [];
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex] ?? [];
+    const candidate = {};
+    for (let columnIndex = 0; columnIndex < headers.length; columnIndex++) {
+      const header = headers[columnIndex];
+      if (!header) {
+        continue;
+      }
+      const path = parseHeaderPath(header);
+      if (!path.length) {
+        continue;
+      }
+      const cellSchema = getSchemaAtPath(schema, path);
+      const cellValue = toTypedCellValue(row[columnIndex], cellSchema);
+      if (cellValue !== void 0) {
+        setDeep(candidate, path, cellValue);
+      }
+    }
+    const parsed = schema.safeParse(candidate);
+    if (!parsed.success) {
+      errors.push(`Row ${rowIndex + 2}: ${formatZodError(parsed.error)}`);
+      continue;
+    }
+    records.push(parsed.data);
+  }
+  return { records, errors };
+}

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

@@ -0,0 +1,17 @@
+export type WriteOutputFormat = 'frontmatter' | 'json' | 'yaml';
+export type WriteOverwriteMode = 'skip' | 'overwrite' | 'overwrite-frontmatter';
+export type WriteAction = 'written' | 'overwritten' | 'skipped';
+export interface WriteRecordInput {
+    record: Record<string, unknown>;
+    baseContentDir: string;
+    folder: string;
+    slugKey: string;
+    orderKey?: string;
+    outputFormat?: WriteOutputFormat;
+    overwriteMode?: WriteOverwriteMode;
+}
+export interface WriteRecordResult {
+    filePath: string;
+    action: WriteAction;
+}
+export declare function writeRecordAsFrontmatter(input: WriteRecordInput): Promise<WriteRecordResult>;

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

@@ -0,0 +1,92 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+function sanitizePathSegment(segment) {
+  return segment.replace(/(^\/+|\/+$)/g, "").replace(/\.\./g, "");
+}
+function getByPath(object, keyPath) {
+  return keyPath.split(".").reduce((acc, key) => {
+    if (acc && typeof acc === "object") {
+      return acc[key];
+    }
+    return void 0;
+  }, object);
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractMarkdownBody(existingFileContent) {
+  const frontmatterMatch = existingFileContent.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  if (!frontmatterMatch) {
+    return existingFileContent;
+  }
+  return existingFileContent.slice(frontmatterMatch[0].length);
+}
+function getFileExtension(format) {
+  if (format === "json") {
+    return "json";
+  }
+  if (format === "yaml") {
+    return "yml";
+  }
+  return "md";
+}
+function stringifyRecord(record, format) {
+  if (format === "json") {
+    return `${JSON.stringify(record, null, 2)}
+`;
+  }
+  const yamlBody = yaml.dump(record, { lineWidth: 360 });
+  if (format === "yaml") {
+    return yamlBody;
+  }
+  return `---
+${yamlBody}---
+`;
+}
+export async function writeRecordAsFrontmatter(input) {
+  const projectRoot = process.cwd();
+  const contentRoot = path.resolve(projectRoot, sanitizePathSegment(input.baseContentDir));
+  const targetFolder = path.resolve(contentRoot, sanitizePathSegment(input.folder));
+  const outputFormat = input.outputFormat ?? "frontmatter";
+  const overwriteMode = input.overwriteMode ?? "overwrite";
+  if (!targetFolder.startsWith(contentRoot)) {
+    throw new Error("Invalid destination folder");
+  }
+  await mkdir(targetFolder, { recursive: true });
+  const slug = String(getByPath(input.record, input.slugKey) ?? "").trim();
+  if (!slug) {
+    throw new Error(`Missing slug value for key "${input.slugKey}"`);
+  }
+  const order = input.orderKey ? String(getByPath(input.record, input.orderKey) ?? "").trim() : "";
+  const extension = getFileExtension(outputFormat);
+  const fileName = `${order ? `${order}.` : ""}${slug}.${extension}`;
+  const filePath = path.resolve(targetFolder, fileName);
+  const exists = await fileExists(filePath);
+  if (exists && overwriteMode === "skip") {
+    return {
+      filePath,
+      action: "skipped"
+    };
+  }
+  if (exists && overwriteMode === "overwrite-frontmatter" && outputFormat === "frontmatter") {
+    const existingFileContent = await readFile(filePath, "utf-8");
+    const markdownBody = extractMarkdownBody(existingFileContent);
+    const nextFrontmatter = stringifyRecord(input.record, "frontmatter");
+    await writeFile(filePath, `${nextFrontmatter}${markdownBody}`, "utf-8");
+    return {
+      filePath,
+      action: "overwritten"
+    };
+  }
+  await writeFile(filePath, stringifyRecord(input.record, outputFormat), "utf-8");
+  return {
+    filePath,
+    action: exists ? "overwritten" : "written"
+  };
+}

package/dist/runtime/types/googleSheetsApi.d.ts

@@ -0,0 +1,75 @@
+export type GoogleSheetsApiValues = string[][];
+export interface GoogleSheetsApiValuesResponse {
+    range: string;
+    majorDimension: string;
+    values: GoogleSheetsApiValues;
+}
+export type GoogleSheetsApiSheet = {
+    properties: {
+        sheetId: string;
+        title: string;
+        index: number;
+        sheetType: string;
+        gridProperties: {
+            rowCount: number;
+            columnCount: number;
+        };
+    };
+};
+export interface GoogleSheetsApiSheetResponse {
+    spreadsheetId: string;
+    properties: {
+        title: string;
+        locale: string;
+        autoRecalc: string;
+        timeZone: string;
+        defaultFormat: {
+            backgroundColor: {
+                red: number;
+                green: number;
+                blue: number;
+            };
+            padding: {
+                top: number;
+                right: number;
+                bottom: number;
+                left: number;
+            };
+            verticalAlignment: string;
+            wrapStrategy: string;
+            textFormat: {
+                foregroundColorStyle: {
+                    rgbColor: {
+                        red: number;
+                        green: number;
+                        blue: number;
+                    };
+                };
+                foregroundColor: {
+                    red: number;
+                    green: number;
+                    blue: number;
+                };
+                fontSize: number;
+                bold: boolean;
+                italic: boolean;
+                strikethrough: boolean;
+                underline: boolean;
+                fontFamily: string;
+            };
+            backgroundColorStyle: {
+                rgbColor: {
+                    red: number;
+                    green: number;
+                    blue: number;
+                };
+            };
+        };
+    };
+    sheets: GoogleSheetsApiSheet[];
+    spreadsheetUrl: string;
+}
+export interface ProductObject {
+    [key: string]: string;
+}
+export type TransformedGoogleSheetsApiResult = ProductObject[];

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "nuxt-google-sheets-import",
+  "version": "0.1.4",
+  "description": "Schema-driven Google Sheets import module for Nuxt Content",
+  "repository": "tribeweb/nuxt-google-sheets-import",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@nuxt/content": "^3.12.0",
+    "@nuxt/kit": "^4.3.1",
+    "@nuxt/ui": "^4.5.1",
+    "better-sqlite3": "^12.6.2",
+    "js-yaml": "^4.1.1",
+    "tailwindcss": "^4.2.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@iconify-json/heroicons": "^1.2.3",
+    "@iconify-json/lucide": "^1.2.95",
+    "@nuxt/devtools": "^3.2.1",
+    "@nuxt/eslint-config": "^1.15.1",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.3.1",
+    "@nuxt/test-utils": "^4.0.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.0.1",
+    "nuxt": "^4.3.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.18",
+    "vue-tsc": "^3.2.5"
+  }
+}