cosmolo 0.3.9 → 0.5.0

package/dist/cli/migrate/drizzle-setup.js

@@ -0,0 +1,411 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { execSync } from 'child_process';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS } from './schema.js';
+// ─── readline helpers ─────────────────────────────────────────────────────────
+function ask(rl, question, fallback = '') {
+    const hint = fallback ? ` [${fallback}]` : '';
+    return new Promise((resolve) => rl.question(`  ${question}${hint}: `, (ans) => resolve(ans.trim() || fallback)));
+}
+function confirm(rl, question) {
+    return new Promise((resolve) => rl.question(`  ${question} [y/N] `, (ans) => resolve(ans.trim().toLowerCase() === 'y')));
+}
+// ─── Drizzle schema generation ────────────────────────────────────────────────
+function drizzleColumnDef(col) {
+    const fn = col.type === 'TEXT' ? 'text' : 'integer';
+    let chain = `  ${col.name}: ${fn}('${col.name}')`;
+    if (col.primaryKey) {
+        chain += '.primaryKey()';
+    }
+    else {
+        if (col.notNull)
+            chain += '.notNull()';
+        if (col.defaultValue !== undefined) {
+            const val = typeof col.defaultValue === 'string' ? `'${col.defaultValue}'` : col.defaultValue;
+            chain += `.default(${val})`;
+        }
+    }
+    return chain + ',';
+}
+function generateDrizzleSchema() {
+    const catCols = CATEGORY_COLUMNS.map(drizzleColumnDef).join('\n');
+    const artCols = ARTICLE_COLUMNS.map(drizzleColumnDef).join('\n');
+    return (`import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';\n\n` +
+        `export const categories = sqliteTable('categories', {\n${catCols}\n});\n\n` +
+        `export const articles = sqliteTable('articles', {\n${artCols}\n});\n`);
+}
+// ─── CRUD file generation ─────────────────────────────────────────────────────
+function generateArticlesCrud() {
+    return `import { drizzle } from 'drizzle-orm/d1';
+import { and, desc, eq, sql } from 'drizzle-orm';
+import { articles } from '../../drizzle/schema';
+
+export function createDb(d1: D1Database) {
+  return drizzle(d1);
+}
+
+export function parseArticle<T extends { tags: string | null; related: string | null }>(row: T) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags ?? '[]') as string[],
+    related: JSON.parse(row.related ?? '[]') as string[],
+  };
+}
+
+export async function getArticles(d1: D1Database) {
+  return createDb(d1)
+    .select()
+    .from(articles)
+    .where(eq(articles.draft, 0))
+    .orderBy(desc(articles.sort));
+}
+
+export async function getArticlesByCategory(d1: D1Database, category: string) {
+  return createDb(d1)
+    .select()
+    .from(articles)
+    .where(and(eq(articles.draft, 0), eq(articles.category, category)))
+    .orderBy(desc(articles.sort));
+}
+
+export async function getArticlesByTag(d1: D1Database, tag: string) {
+  return createDb(d1)
+    .select()
+    .from(articles)
+    .where(
+      and(
+        eq(articles.draft, 0),
+        sql\`EXISTS (SELECT 1 FROM json_each(\${articles.tags}) WHERE value = \${tag})\`
+      )
+    )
+    .orderBy(desc(articles.sort));
+}
+
+export async function getArticle(d1: D1Database, slug: string) {
+  const [row] = await createDb(d1).select().from(articles).where(eq(articles.slug, slug));
+  return row ?? null;
+}
+
+export async function createArticle(d1: D1Database, data: typeof articles.$inferInsert) {
+  return createDb(d1).insert(articles).values(data).returning();
+}
+
+export async function updateArticle(
+  d1: D1Database,
+  slug: string,
+  data: Partial<typeof articles.$inferInsert>
+) {
+  return createDb(d1).update(articles).set(data).where(eq(articles.slug, slug)).returning();
+}
+
+export async function deleteArticle(d1: D1Database, slug: string) {
+  return createDb(d1).delete(articles).where(eq(articles.slug, slug));
+}
+`;
+}
+function generateCategoriesCrud() {
+    return `import { drizzle } from 'drizzle-orm/d1';
+import { eq } from 'drizzle-orm';
+import { categories } from '../../drizzle/schema';
+
+export function createDb(d1: D1Database) {
+  return drizzle(d1);
+}
+
+export async function getCategories(d1: D1Database) {
+  return createDb(d1).select().from(categories);
+}
+
+export async function getCategory(d1: D1Database, key: string) {
+  const [row] = await createDb(d1).select().from(categories).where(eq(categories.key, key));
+  return row ?? null;
+}
+
+export async function createCategory(d1: D1Database, data: typeof categories.$inferInsert) {
+  return createDb(d1).insert(categories).values(data).returning();
+}
+
+export async function updateCategory(
+  d1: D1Database,
+  key: string,
+  data: Partial<typeof categories.$inferInsert>
+) {
+  return createDb(d1).update(categories).set(data).where(eq(categories.key, key)).returning();
+}
+
+export async function deleteCategory(d1: D1Database, key: string) {
+  return createDb(d1).delete(categories).where(eq(categories.key, key));
+}
+`;
+}
+// ─── Route file generation ────────────────────────────────────────────────────
+function generateHomeRoute() {
+    return `import type { PageServerLoad } from './$types';
+import { getArticles, parseArticle } from '$lib/db/articles';
+import { getCategories } from '$lib/db/categories';
+import siteConfig from '../../config/site.json';
+
+export const load: PageServerLoad = async ({ platform }) => {
+  const db = platform!.env.DB;
+  const [rawArticles, categories] = await Promise.all([getArticles(db), getCategories(db)]);
+  return {
+    articles: rawArticles.map(parseArticle),
+    categories,
+    articlesPerPage: siteConfig.articlesPerPage ?? 10,
+  };
+};
+`;
+}
+function generateArticleRoute() {
+    return `import type { PageServerLoad } from './$types';
+import { error } from '@sveltejs/kit';
+import { marked } from 'marked';
+import { getArticle, parseArticle } from '$lib/db/articles';
+import { getCategories } from '$lib/db/categories';
+
+export const load: PageServerLoad = async ({ params, platform }) => {
+  const db = platform!.env.DB;
+  const [raw, categories] = await Promise.all([getArticle(db, params.slug), getCategories(db)]);
+  if (!raw) error(404, 'Article not found');
+  const article = {
+    ...parseArticle(raw),
+    body: await marked(raw.body ?? ''),
+  };
+  return { article, categories };
+};
+`;
+}
+function generateCategoryRoute() {
+    return `import type { PageServerLoad } from './$types';
+import { error } from '@sveltejs/kit';
+import { getArticlesByCategory, parseArticle } from '$lib/db/articles';
+import { getCategory } from '$lib/db/categories';
+import siteConfig from '../../../../config/site.json';
+
+export const load: PageServerLoad = async ({ params, platform }) => {
+  const db = platform!.env.DB;
+  const [rawArticles, category] = await Promise.all([
+    getArticlesByCategory(db, params.slug),
+    getCategory(db, params.slug),
+  ]);
+  if (!category) error(404, 'Category not found');
+  return {
+    articles: rawArticles.map(parseArticle),
+    category,
+    articlesPerPage: siteConfig.articlesPerPage ?? 10,
+  };
+};
+`;
+}
+function generateTagRoute() {
+    return `import type { PageServerLoad } from './$types';
+import { getArticlesByTag, parseArticle } from '$lib/db/articles';
+import siteConfig from '../../../../config/site.json';
+
+export const load: PageServerLoad = async ({ params, platform }) => {
+  const db = platform!.env.DB;
+  const rawArticles = await getArticlesByTag(db, params.tag);
+  return {
+    articles: rawArticles.map(parseArticle),
+    tag: params.tag,
+    articlesPerPage: siteConfig.articlesPerPage ?? 10,
+  };
+};
+`;
+}
+function generateDrizzleConfig() {
+    return `import type { Config } from 'drizzle-kit';
+
+export default {
+  schema: './drizzle/schema.ts',
+  out: './drizzle/migrations',
+  dialect: 'sqlite',
+} satisfies Config;
+`;
+}
+function generateDevVarsExample() {
+    return `CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_DATABASE_ID=
+CLOUDFLARE_D1_TOKEN=
+`;
+}
+// ─── wrangler.toml helpers ────────────────────────────────────────────────────
+function d1Section(dbName) {
+    return (`\n[[d1_databases]]\n` +
+        `binding = "DB"\n` +
+        `database_name = "${dbName}"\n` +
+        `database_id = "REPLACE_WITH_YOUR_DATABASE_ID"\n`);
+}
+function updateWranglerToml(root, dbName) {
+    const wranglerPath = path.join(root, 'wrangler.toml');
+    if (fs.existsSync(wranglerPath)) {
+        const existing = fs.readFileSync(wranglerPath, 'utf-8');
+        fs.writeFileSync(wranglerPath, existing + d1Section(dbName));
+        return 'appended';
+    }
+    const minimal = `name = "cosmolo-site"\n` +
+        `compatibility_date = "2025-01-01"\n` +
+        d1Section(dbName);
+    fs.writeFileSync(wranglerPath, minimal);
+    return 'created';
+}
+// ─── preflight checks ─────────────────────────────────────────────────────────
+async function preflight(root, rl) {
+    console.log('\n  Checking environment...\n');
+    // drizzle-orm installed?
+    const drizzleInstalled = fs.existsSync(path.join(root, 'node_modules', 'drizzle-orm'));
+    if (!drizzleInstalled) {
+        console.log('  drizzle-orm is not installed.');
+        const install = await confirm(rl, 'Install drizzle-orm and drizzle-kit now?');
+        if (install) {
+            console.log('  Running: bun add drizzle-orm drizzle-kit ...');
+            execSync('bun add drizzle-orm drizzle-kit', { stdio: 'inherit', cwd: root });
+        }
+        else {
+            console.log('  Install drizzle-orm and drizzle-kit manually, then re-run migrate:db.');
+            return null;
+        }
+    }
+    // wrangler.toml: existing D1 binding?
+    const wranglerPath = path.join(root, 'wrangler.toml');
+    if (fs.existsSync(wranglerPath)) {
+        const content = fs.readFileSync(wranglerPath, 'utf-8');
+        if (content.includes('[[d1_databases]]')) {
+            console.log('  Warning: wrangler.toml already contains [[d1_databases]].');
+            const proceed = await confirm(rl, 'Add another D1 binding anyway?');
+            if (!proceed)
+                return null;
+        }
+    }
+    // drizzle/schema.ts exists?
+    const schemaPath = path.join(root, 'drizzle', 'schema.ts');
+    if (fs.existsSync(schemaPath)) {
+        const ok = await confirm(rl, 'drizzle/schema.ts already exists. Overwrite?');
+        if (!ok)
+            return null;
+        // table name conflict check
+        const existing = fs.readFileSync(schemaPath, 'utf-8');
+        const conflicts = ['articles', 'categories'].filter((t) => existing.includes(`sqliteTable('${t}'`));
+        if (conflicts.length > 0) {
+            console.log(`  Warning: table(s) already defined in schema: ${conflicts.join(', ')}`);
+            const ok2 = await confirm(rl, 'Continue and overwrite?');
+            if (!ok2)
+                return null;
+        }
+    }
+    // drizzle.config.ts exists?
+    const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+    if (fs.existsSync(drizzleConfigPath)) {
+        const ok = await confirm(rl, 'drizzle.config.ts already exists. Overwrite?');
+        if (!ok)
+            return null;
+    }
+    // src/lib/db/ CRUD files exist?
+    const dbDir = path.join(root, 'src', 'lib', 'db');
+    const crudFiles = ['articles.ts', 'categories.ts'].filter((f) => fs.existsSync(path.join(dbDir, f)));
+    if (crudFiles.length > 0) {
+        console.log(`  Warning: src/lib/db/${crudFiles.join(', ')} already exist.`);
+        const ok = await confirm(rl, 'Overwrite CRUD files?');
+        if (!ok)
+            return null;
+    }
+    // D1 database name
+    const dbName = await ask(rl, 'D1 database name', 'cosmolo');
+    // Generate D1-backed routes?
+    const routePaths = [
+        path.join('src', 'routes', '+page.server.ts'),
+        path.join('src', 'routes', 'articles', '[slug]', '+page.server.ts'),
+        path.join('src', 'routes', 'categories', '[slug]', '+page.server.ts'),
+        path.join('src', 'routes', 'tags', '[tag]', '+page.server.ts'),
+    ];
+    const existingRoutes = routePaths.filter((p) => fs.existsSync(path.join(root, p)));
+    let generateRoutes = true;
+    if (existingRoutes.length > 0) {
+        console.log(`\n  The following route files will be replaced with D1-backed versions:`);
+        for (const p of existingRoutes)
+            console.log(`    ${p}`);
+        generateRoutes = await confirm(rl, 'Replace with D1-backed route files?');
+    }
+    else {
+        generateRoutes = await confirm(rl, 'Generate D1-backed route files?');
+    }
+    return { dbName, generateRoutes };
+}
+// ─── main ─────────────────────────────────────────────────────────────────────
+export async function drizzleSetup(_config) {
+    const root = process.cwd();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const result = await preflight(root, rl);
+    rl.close();
+    if (!result)
+        return;
+    const { dbName, generateRoutes } = result;
+    // Generate drizzle/schema.ts
+    const drizzleDir = path.join(root, 'drizzle');
+    fs.mkdirSync(drizzleDir, { recursive: true });
+    fs.writeFileSync(path.join(drizzleDir, 'schema.ts'), generateDrizzleSchema());
+    // Generate src/lib/db/articles.ts and categories.ts
+    const dbDir = path.join(root, 'src', 'lib', 'db');
+    fs.mkdirSync(dbDir, { recursive: true });
+    fs.writeFileSync(path.join(dbDir, 'articles.ts'), generateArticlesCrud());
+    fs.writeFileSync(path.join(dbDir, 'categories.ts'), generateCategoriesCrud());
+    // drizzle.config.ts
+    fs.writeFileSync(path.join(root, 'drizzle.config.ts'), generateDrizzleConfig());
+    // .dev.vars.example
+    if (!fs.existsSync(path.join(root, '.dev.vars.example'))) {
+        fs.writeFileSync(path.join(root, '.dev.vars.example'), generateDevVarsExample());
+    }
+    // wrangler.toml
+    const wranglerAction = updateWranglerToml(root, dbName);
+    // D1-backed route files
+    if (generateRoutes) {
+        const routesDir = path.join(root, 'src', 'routes');
+        const routeFiles = [
+            [path.join(routesDir, '+page.server.ts'), generateHomeRoute()],
+            [path.join(routesDir, 'articles', '[slug]', '+page.server.ts'), generateArticleRoute()],
+            [path.join(routesDir, 'categories', '[slug]', '+page.server.ts'), generateCategoryRoute()],
+            [path.join(routesDir, 'tags', '[tag]', '+page.server.ts'), generateTagRoute()],
+        ];
+        for (const [filePath, content] of routeFiles) {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, content);
+        }
+    }
+    console.log('\n✓ Files generated:');
+    console.log('  drizzle/schema.ts');
+    console.log('  src/lib/db/articles.ts');
+    console.log('  src/lib/db/categories.ts');
+    console.log('  drizzle.config.ts');
+    console.log('  .dev.vars.example');
+    console.log(`  wrangler.toml  (${wranglerAction})`);
+    if (generateRoutes) {
+        console.log('  src/routes/+page.server.ts');
+        console.log('  src/routes/articles/[slug]/+page.server.ts');
+        console.log('  src/routes/categories/[slug]/+page.server.ts');
+        console.log('  src/routes/tags/[tag]/+page.server.ts');
+    }
+    let step = 1;
+    console.log('\nNext steps:\n');
+    console.log(`  ${step++}. Create the D1 database (if not done yet):`);
+    console.log(`       bunx wrangler d1 create ${dbName}`);
+    console.log(`     Copy the database_id into wrangler.toml.\n`);
+    console.log(`  ${step++}. Generate migration files:`);
+    console.log(`       bunx drizzle-kit generate\n`);
+    console.log(`  ${step++}. Apply migrations locally:`);
+    console.log(`       bunx wrangler d1 migrations apply ${dbName} --local\n`);
+    console.log(`  ${step++}. Seed content from Markdown files:`);
+    console.log(`       bunx cosmolo migrate:db  → choose Option 1 to export SQL`);
+    console.log(`       bunx wrangler d1 execute ${dbName} --local --file=cosmolo-migration/002_seed_categories.sql`);
+    console.log(`       bunx wrangler d1 execute ${dbName} --local --file=cosmolo-migration/003_seed_articles.sql\n`);
+    if (generateRoutes) {
+        console.log(`  ${step++}. Install marked for Markdown rendering in routes:`);
+        console.log(`       bun add marked\n`);
+    }
+    console.log(`  ${step++}. Install Cloudflare Workers types for TypeScript:`);
+    console.log(`       bun add -d @cloudflare/workers-types\n`);
+    console.log(`  ${step++}. Ensure src/app.d.ts declares the DB binding:`);
+    console.log(`       interface Platform { env: { DB: D1Database } }`);
+    console.log(`       (cosmolo init --cloudflare does this automatically)\n`);
+    console.log(`  See docs/DB_MIGRATION.md for full details.`);
+}

package/dist/cli/migrate/schema.d.ts

@@ -0,0 +1,12 @@
+export interface SqlColumn {
+    name: string;
+    type: 'TEXT' | 'INTEGER';
+    notNull: boolean;
+    defaultValue?: string | number;
+    primaryKey?: boolean;
+}
+export declare const ARTICLE_COLUMNS: SqlColumn[];
+export declare const CATEGORY_COLUMNS: SqlColumn[];
+export declare function createTableSql(tableName: string, columns: SqlColumn[]): string;
+export declare function escapeSql(val: string): string;
+export declare function toSqlLiteral(val: unknown): string;

package/dist/cli/migrate/schema.js

@@ -0,0 +1,56 @@
+// Derived from articleFrontmatterSchema in articles.ts.
+// Arrays are stored as JSON text. Booleans as INTEGER (0/1, SQLite convention).
+export const ARTICLE_COLUMNS = [
+    { name: 'slug', type: 'TEXT', notNull: true, primaryKey: true },
+    { name: 'title', type: 'TEXT', notNull: true },
+    { name: 'category', type: 'TEXT', notNull: true },
+    { name: 'excerpt', type: 'TEXT', notNull: true },
+    { name: 'sort', type: 'INTEGER', notNull: true, defaultValue: 0 },
+    { name: 'date', type: 'TEXT', notNull: true, defaultValue: '' },
+    { name: 'tags', type: 'TEXT', notNull: true, defaultValue: '[]' },
+    { name: 'series', type: 'TEXT', notNull: false },
+    { name: 'series_order', type: 'INTEGER', notNull: false },
+    { name: 'draft', type: 'INTEGER', notNull: true, defaultValue: 0 },
+    { name: 'related', type: 'TEXT', notNull: true, defaultValue: '[]' },
+    { name: 'body', type: 'TEXT', notNull: true },
+];
+export const CATEGORY_COLUMNS = [
+    { name: 'key', type: 'TEXT', notNull: true, primaryKey: true },
+    { name: 'label', type: 'TEXT', notNull: true },
+    { name: 'description', type: 'TEXT', notNull: true, defaultValue: '' },
+];
+function columnDef(col) {
+    let def = `  ${col.name} ${col.type}`;
+    if (col.primaryKey) {
+        def += ' PRIMARY KEY';
+    }
+    else {
+        if (col.notNull)
+            def += ' NOT NULL';
+        if (col.defaultValue !== undefined) {
+            const val = typeof col.defaultValue === 'string' ? `'${col.defaultValue}'` : col.defaultValue;
+            def += ` DEFAULT ${val}`;
+        }
+    }
+    return def;
+}
+export function createTableSql(tableName, columns) {
+    const defs = columns.map(columnDef).join(',\n');
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (\n${defs}\n);`;
+}
+export function escapeSql(val) {
+    return val.replace(/'/g, "''");
+}
+export function toSqlLiteral(val) {
+    if (val === null || val === undefined)
+        return 'NULL';
+    if (typeof val === 'boolean')
+        return val ? '1' : '0';
+    if (typeof val === 'number')
+        return String(val);
+    if (val instanceof Date)
+        return `'${escapeSql(val.toISOString().split('T')[0])}'`;
+    if (Array.isArray(val))
+        return `'${escapeSql(JSON.stringify(val))}'`;
+    return `'${escapeSql(String(val))}'`;
+}

package/dist/cli/migrate/sql-execute.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedCosmoloConfig } from '../../types.js';
+export declare function executeSqlDirect(config: ResolvedCosmoloConfig): Promise<void>;

package/dist/cli/migrate/sql-execute.js

@@ -0,0 +1,67 @@
+import * as path from 'path';
+import * as readline from 'readline';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS, createTableSql } from './schema.js';
+import { buildCategoriesInserts, buildArticlesInserts } from './sql-export.js';
+function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(`${question} [y/N] `, (ans) => {
+        rl.close();
+        resolve(ans.trim().toLowerCase() === 'y');
+    }));
+}
+function resolveDbPath(url) {
+    // Reject known non-SQLite URL schemes
+    if (/^(postgres|postgresql|mysql|mariadb|mongodb):\/\//i.test(url))
+        return null;
+    return url.replace(/^(sqlite:|file:)/, '');
+}
+export async function executeSqlDirect(config) {
+    const dbUrl = process.env.DATABASE_URL;
+    if (!dbUrl) {
+        console.error('\n  DATABASE_URL is not set.');
+        console.error('  Example: DATABASE_URL=./mysite.db bunx cosmolo migrate:db');
+        process.exit(1);
+    }
+    const dbPath = resolveDbPath(dbUrl);
+    if (!dbPath) {
+        console.error('\n  Only SQLite databases are supported for direct execution.');
+        console.error('  Use Option 1 to export SQL files for other database engines.');
+        process.exit(1);
+    }
+    const root = process.cwd();
+    const catInserts = buildCategoriesInserts(path.join(root, config.categoriesConfigPath));
+    const artInserts = buildArticlesInserts(path.join(root, config.articlesDir));
+    console.log(`\n  Target:     ${dbPath}`);
+    console.log(`  Categories: ${catInserts.length} rows`);
+    console.log(`  Articles:   ${artInserts.length} rows`);
+    const ok = await confirm('\n  Proceed?');
+    if (!ok) {
+        console.log('  Aborted.');
+        return;
+    }
+    // bun:sqlite is a bun built-in; the 'bun:' scheme is not a standard ESM URL
+    // so we suppress the TypeScript module resolution error here.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(dbPath);
+    try {
+        db.run('BEGIN TRANSACTION');
+        db.run(createTableSql('categories', CATEGORY_COLUMNS));
+        db.run(createTableSql('articles', ARTICLE_COLUMNS));
+        for (const sql of catInserts)
+            db.run(sql);
+        for (const sql of artInserts)
+            db.run(sql);
+        db.run('COMMIT');
+        console.log('\n  ✓ Migration complete.');
+    }
+    catch (err) {
+        db.run('ROLLBACK');
+        console.error('\n  Migration failed:', err);
+        process.exit(1);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/migrate/sql-export.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCosmoloConfig } from '../../types.js';
+export declare function buildCategoriesInserts(categoriesPath: string): string[];
+export declare function buildArticlesInserts(articlesDir: string): string[];
+export declare function exportSqlFiles(config: ResolvedCosmoloConfig): Promise<void>;

package/dist/cli/migrate/sql-export.js

@@ -0,0 +1,76 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { ARTICLE_COLUMNS, CATEGORY_COLUMNS, createTableSql, escapeSql, toSqlLiteral, } from './schema.js';
+export function buildCategoriesInserts(categoriesPath) {
+    if (!fs.existsSync(categoriesPath))
+        return [];
+    const raw = JSON.parse(fs.readFileSync(categoriesPath, 'utf-8'));
+    return Object.entries(raw).map(([key, entry]) => {
+        const label = escapeSql(entry.label ?? '');
+        const description = escapeSql(entry.description ?? '');
+        return `INSERT INTO categories (key, label, description) VALUES ('${escapeSql(key)}', '${label}', '${description}');`;
+    });
+}
+function collectArticleFiles(dir, baseDir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectArticleFiles(fullPath, baseDir));
+        }
+        else if (/\.(md|svx)$/.test(entry.name)) {
+            const rel = path.relative(baseDir, fullPath).replace(/\.(md|svx)$/, '');
+            // Normalize path separators to forward slashes for slug
+            results.push({ filePath: fullPath, slug: rel.replace(/\\/g, '/') });
+        }
+    }
+    return results;
+}
+export function buildArticlesInserts(articlesDir) {
+    if (!fs.existsSync(articlesDir))
+        return [];
+    return collectArticleFiles(articlesDir, articlesDir).map(({ filePath, slug }) => {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { data, content } = matter(raw);
+        const dateVal = data.date instanceof Date
+            ? data.date.toISOString().split('T')[0]
+            : (data.date ?? '');
+        const values = [
+            toSqlLiteral(slug),
+            toSqlLiteral(data.title ?? ''),
+            toSqlLiteral(data.category ?? ''),
+            toSqlLiteral(data.excerpt ?? ''),
+            toSqlLiteral(data.sort ?? 0),
+            toSqlLiteral(dateVal),
+            toSqlLiteral(data.tags ?? []),
+            toSqlLiteral(data.series ?? null),
+            toSqlLiteral(data.seriesOrder ?? null),
+            toSqlLiteral(data.draft ?? false),
+            toSqlLiteral(data.related ?? []),
+            toSqlLiteral(content),
+        ].join(', ');
+        const cols = 'slug, title, category, excerpt, sort, date, tags, series, series_order, draft, related, body';
+        return `INSERT INTO articles (${cols}) VALUES (${values});`;
+    });
+}
+export async function exportSqlFiles(config) {
+    const root = process.cwd();
+    const outputDir = path.join(root, 'cosmolo-migration');
+    fs.mkdirSync(outputDir, { recursive: true });
+    const createSql = createTableSql('categories', CATEGORY_COLUMNS) +
+        '\n\n' +
+        createTableSql('articles', ARTICLE_COLUMNS);
+    fs.writeFileSync(path.join(outputDir, '001_create_tables.sql'), createSql + '\n');
+    const categoriesPath = path.join(root, config.categoriesConfigPath);
+    const catInserts = buildCategoriesInserts(categoriesPath);
+    fs.writeFileSync(path.join(outputDir, '002_seed_categories.sql'), catInserts.join('\n') + '\n');
+    const articlesDir = path.join(root, config.articlesDir);
+    const artInserts = buildArticlesInserts(articlesDir);
+    fs.writeFileSync(path.join(outputDir, '003_seed_articles.sql'), artInserts.join('\n') + '\n');
+    console.log(`\n✓ SQL files written to cosmolo-migration/`);
+    console.log('  001_create_tables.sql');
+    console.log(`  002_seed_categories.sql  (${catInserts.length} rows)`);
+    console.log(`  003_seed_articles.sql    (${artInserts.length} rows)`);
+    console.log('\nReview the files and run them against your database.');
+}

package/dist/cli/migrate.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;