@async/db 0.2.0

package/dist/features/viewer/manifest.js

@@ -0,0 +1,165 @@
+import { resolveFrom, writeText } from '../../fs-utils.js';
+import { restFormatMetadata } from '../../rest/formats.js';
+import { loadProjectSchema } from '../schema/project.js';
+import { renderSchemaManifest } from '../schema/manifest.js';
+export async function generateViewerManifest(config, options = {}) {
+    const project = (options.project ?? await loadProjectSchema(config));
+    const manifest = renderViewerManifest(project.resources, config, {
+        diagnostics: project.diagnostics,
+        generatedAt: options.generatedAt,
+        routes: options.routes,
+    });
+    const content = `${JSON.stringify(manifest, null, 2)}\n`;
+    const outFiles = outputFiles(config, options);
+    for (const outFile of outFiles) {
+        await writeText(outFile, content);
+    }
+    return {
+        manifest,
+        content,
+        outFiles,
+        diagnostics: project.diagnostics,
+    };
+}
+export function renderViewerManifest(resources, config = {}, options = {}) {
+    const schemaManifest = renderSchemaManifest(resources, config);
+    const routes = normalizeViewerRoutes(config, options.routes);
+    const resourceList = [...resources];
+    const collections = resourceBucketManifest(schemaManifest.collections, resourceList, routes);
+    const documents = resourceBucketManifest(schemaManifest.documents, resourceList, routes);
+    const restEnabled = config.rest?.enabled !== false;
+    return {
+        version: 1,
+        kind: 'db.viewerManifest',
+        generatedAt: options.generatedAt ?? new Date().toISOString(),
+        api: {
+            viewer: routes.viewerPath,
+            manifest: routes.manifestPath,
+            manifestJson: routes.manifestJsonPath,
+            manifestHtml: routes.manifestHtmlPath,
+            manifestMarkdown: routes.manifestMarkdownPath,
+            formats: restFormatMetadata(config, routes),
+            viewers: viewerLinks(config, routes.viewerPath),
+            schema: routes.schemaPath,
+            events: routes.eventsPath,
+            log: routes.logPath,
+            batch: routes.batchPath,
+            import: routes.importPath,
+            graphql: routes.graphqlPath,
+            restBasePath: routes.restBasePath ?? '',
+            resources: Object.fromEntries(resourceList.map((resource) => [resource.name, resourceApi(resource, routes)])),
+        },
+        capabilities: {
+            collections: resourceList.some((resource) => resource.kind === 'collection'),
+            documents: resourceList.some((resource) => resource.kind === 'document'),
+            rest: restEnabled,
+            writes: restEnabled,
+            restBatch: restEnabled,
+            graphql: config.graphql?.enabled !== false,
+            csvImport: true,
+            liveEvents: true,
+        },
+        collections,
+        documents,
+        diagnostics: options.diagnostics ?? [],
+    };
+}
+function outputFiles(config, options) {
+    const outFile = options.outFile
+        ? resolveFrom(config.cwd ?? '.', options.outFile)
+        : config.viewerManifestOutFile;
+    return outFile ? [outFile] : [];
+}
+function resourceBucketManifest(bucket = {}, resources, routes) {
+    return Object.fromEntries(Object.entries(bucket).map(([resourceName, manifest]) => {
+        const resource = resources.find((candidate) => candidate.name === resourceName);
+        if (!resource) {
+            return [resourceName, manifest];
+        }
+        return [resourceName, {
+                ...manifest,
+                typeName: resource.typeName,
+                routePath: resource.routePath,
+                api: resourceApi(resource, routes),
+                relations: resource.relations ?? [],
+            }];
+    }));
+}
+function resourceApi(resource, routes) {
+    const route = joinPaths(routes.restBasePath ?? '', resource.routePath);
+    if (resource.kind === 'document') {
+        return {
+            kind: 'document',
+            read: route,
+            write: route,
+        };
+    }
+    return {
+        kind: 'collection',
+        list: route,
+        record: `${route}/{${resource.idField ?? 'id'}}`,
+    };
+}
+function normalizeViewerRoutes(config, routes = {}) {
+    const apiBase = normalizeBasePath(routes.apiBase ?? config.server?.apiBase ?? '/__db');
+    const restBasePath = routes.restBasePath === null
+        ? ''
+        : normalizeBasePath(routes.restBasePath ?? '');
+    return {
+        apiBase,
+        viewerPath: routes.viewerPath ?? apiBase,
+        manifestPath: routes.manifestPath ?? `${apiBase}/manifest`,
+        manifestJsonPath: routes.manifestJsonPath ?? `${apiBase}/manifest.json`,
+        manifestHtmlPath: routes.manifestHtmlPath ?? `${apiBase}/manifest.html`,
+        manifestMarkdownPath: routes.manifestMarkdownPath ?? `${apiBase}/manifest.md`,
+        schemaPath: routes.schemaPath ?? `${apiBase}/schema`,
+        eventsPath: routes.eventsPath ?? `${apiBase}/events`,
+        logPath: routes.logPath ?? `${apiBase}/log`,
+        batchPath: routes.batchPath ?? `${apiBase}/batch`,
+        importPath: routes.importPath ?? `${apiBase}/import`,
+        graphqlPath: routes.graphqlPath ?? config.graphql?.path ?? '/graphql',
+        restBasePath,
+    };
+}
+function viewerLinks(config, viewerPath) {
+    const configuredLinks = Array.isArray(config.server?.viewerLinks)
+        ? config.server.viewerLinks
+        : [];
+    return [
+        {
+            label: 'Data Viewer',
+            href: viewerPath,
+            source: 'built-in',
+        },
+        ...configuredLinks.map(normalizeViewerLink).filter(Boolean),
+    ];
+}
+function normalizeViewerLink(link) {
+    if (!isRecord(link)) {
+        return null;
+    }
+    const href = typeof link.href === 'string' ? link.href : link.url;
+    if (typeof href !== 'string' || href.trim() === '') {
+        return null;
+    }
+    return {
+        label: typeof link.label === 'string' && link.label.trim() ? link.label : 'Custom Viewer',
+        href,
+        source: 'custom',
+    };
+}
+function joinPaths(basePath, routePath) {
+    if (!basePath) {
+        return routePath;
+    }
+    const base = `/${String(basePath).replace(/^\/+/, '').replace(/\/+$/, '')}`;
+    const route = `/${String(routePath || '/').replace(/^\/+/, '')}`;
+    return `${base}${route === '/' ? '' : route}`;
+}
+function normalizeBasePath(value) {
+    const pathValue = `/${String(value ?? '').replace(/^\/+/, '').replace(/\/+$/, '')}`;
+    return pathValue === '/' ? '' : pathValue;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/fs-utils.d.ts

@@ -0,0 +1 @@
+export { readText, resolveFrom, toPosixPath, writeText } from './shared/fs-utils.js';

package/dist/fs-utils.js

@@ -0,0 +1 @@
+export { readText, resolveFrom, toPosixPath, writeText } from './shared/fs-utils.js';

package/dist/generate/hono/app.d.ts

@@ -0,0 +1,6 @@
+type HonoAppRenderOptions = {
+    api: string[];
+};
+export declare function renderHonoApp(options: HonoAppRenderOptions): string;
+export declare function renderServerEntry(): string;
+export {};

package/dist/generate/hono/app.js

@@ -0,0 +1,51 @@
+export function renderHonoApp(options) {
+    const imports = [
+        "import { Hono } from 'hono';",
+        "import { openSqliteRepository } from './sqlite.js';",
+    ];
+    const registrations = [];
+    if (options.api.includes('rest')) {
+        imports.push("import { registerDbRoutes } from './rest.js';");
+        registrations.push('registerDbRoutes(app, repository);');
+    }
+    if (options.api.includes('graphql')) {
+        imports.push("import { registerGraphqlRoutes } from './graphql.js';");
+        registrations.push('registerGraphqlRoutes(app, repository);');
+    }
+    return `${generatedHeader()}
+${imports.join('\n')}
+
+export const repository = openSqliteRepository();
+export const app = new Hono();
+
+app.onError((error, c) => {
+  const status = typeof (error as any).status === 'number' ? (error as any).status : 500;
+  return c.json({
+    error: {
+      code: (error as any).code || 'SERVER_ERROR',
+      message: error.message,
+    },
+  }, status as any);
+});
+
+${registrations.join('\n')}
+`;
+}
+export function renderServerEntry() {
+    return `${generatedHeader()}
+import { serve } from '@hono/node-server';
+import { app } from './app.js';
+
+const port = Number(process.env.PORT || 3000);
+
+serve({
+  fetch: app.fetch,
+  port,
+});
+
+console.log('db Hono API listening on http://127.0.0.1:' + port);
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono/graphql.d.ts

@@ -0,0 +1,7 @@
+type HonoGraphqlProject = {
+    schema: {
+        graphql?: string;
+    };
+};
+export declare function renderGraphqlRoutes(project: HonoGraphqlProject): string;
+export {};

package/dist/generate/hono/graphql.js

@@ -0,0 +1,53 @@
+export function renderGraphqlRoutes(project) {
+    return `${generatedHeader()}
+import type { Hono } from 'hono';
+import { executeGraphql } from '@async/db';
+import type { DbRepository } from './repository.js';
+
+const graphqlSdl = ${JSON.stringify(project.schema.graphql)};
+
+export function registerGraphqlRoutes(app: Hono, repository: DbRepository, path = '/graphql') {
+  app.get(path, (c) => c.text(graphqlSdl));
+  app.post(path, async (c) => executeGraphql(createDbFacade(repository), await c.req.json()).then((result) => c.json(result)));
+}
+
+function createDbFacade(repository: DbRepository) {
+  return {
+    resources: new Map(Object.entries(repository.resources)),
+    collection(name: string) {
+      return repository.collection(name);
+    },
+    document(name: string) {
+      const document = repository.document(name);
+      return {
+        all: () => document.all(),
+        update: (patch: Record<string, unknown>) => document.patch(patch),
+        put: (value: Record<string, unknown>) => document.put(value),
+        async set(pointer: string, value: unknown) {
+          const current = await document.all();
+          setPointer(current, pointer, value);
+          await document.put(current);
+          return value;
+        },
+      };
+    },
+  };
+}
+
+function setPointer(document: Record<string, unknown>, pointer: string, value: unknown) {
+  const parts = pointer.split('/').slice(1).map((part) => part.replaceAll('~1', '/').replaceAll('~0', '~'));
+  let current: Record<string, unknown> = document;
+  while (parts.length > 1) {
+    const part = parts.shift() as string;
+    if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  current[parts[0] || ''] = value;
+}
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono/index.d.ts

@@ -0,0 +1,55 @@
+type HonoDiagnostic = {
+    severity: 'error' | 'warn' | 'info';
+    message: string;
+    [key: string]: unknown;
+};
+type HonoResource = {
+    name: string;
+    kind: string;
+    idField?: string;
+    fields: Record<string, {
+        type?: string;
+        required?: boolean;
+        [key: string]: unknown;
+    }>;
+    seed?: unknown;
+};
+type HonoProject = {
+    resources: HonoResource[];
+    diagnostics: HonoDiagnostic[];
+    schema: {
+        resources: unknown;
+        graphql?: string;
+        [key: string]: unknown;
+    };
+};
+type HonoGenerateConfig = {
+    cwd?: string;
+    generate?: {
+        hono?: Partial<HonoGenerateOptions>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+type HonoGenerateOptions = {
+    outDir: string;
+    out?: string;
+    api: string[] | string;
+    db: string;
+    app: string;
+    runtime: string;
+    seed: false | 'fixtures' | string | boolean;
+    allowWarnings: boolean;
+    [key: string]: unknown;
+};
+type GeneratedFile = {
+    path: string;
+    content: string;
+};
+export declare function generateHonoStarter(config: HonoGenerateConfig, options?: Partial<HonoGenerateOptions>): Promise<{
+    outDir: string;
+    files: string[];
+    diagnostics: HonoDiagnostic[];
+}>;
+export declare function renderHonoStarter(project: HonoProject, options?: Partial<HonoGenerateOptions>): GeneratedFile[];
+export {};

package/dist/generate/hono/index.js

@@ -0,0 +1,140 @@
+import path from 'node:path';
+import { dbError } from '../../errors.js';
+import { writeText } from '../../fs-utils.js';
+import { loadProjectSchema } from '../../schema.js';
+import { renderHonoApp, renderServerEntry } from './app.js';
+import { renderGraphqlRoutes } from './graphql.js';
+import { renderPackageJson, renderTsconfig } from './package.js';
+import { renderReadme } from './readme.js';
+import { renderRepositoryTypes } from './repository.js';
+import { renderRestRoutes } from './rest.js';
+import { renderGeneratedSchema, renderSeedModule } from './schema.js';
+import { renderInitialMigration, renderSqliteAdapter } from './sqlite.js';
+import { renderValidators } from './validators.js';
+const DEFAULT_OPTIONS = {
+    outDir: './db-api',
+    api: ['rest'],
+    db: 'sqlite',
+    app: 'standalone',
+    runtime: 'node-sqlite',
+    seed: false,
+    allowWarnings: false,
+};
+export async function generateHonoStarter(config, options = {}) {
+    const resolved = resolveGenerateOptions(config, options);
+    const project = await loadProjectSchema(config);
+    assertGeneratable(project, resolved);
+    const files = renderHonoStarter(project, resolved);
+    for (const file of files) {
+        await writeText(path.join(resolved.outDir, file.path), file.content);
+    }
+    return {
+        outDir: resolved.outDir,
+        files: files.map((file) => path.join(resolved.outDir, file.path)),
+        diagnostics: project.diagnostics,
+    };
+}
+export function renderHonoStarter(project, options = {}) {
+    const resolved = {
+        ...DEFAULT_OPTIONS,
+        ...options,
+        api: normalizeApi(options.api ?? DEFAULT_OPTIONS.api),
+    };
+    const files = [
+        generatedFile('src/schema.ts', renderGeneratedSchema(project)),
+        generatedFile('src/repository.ts', renderRepositoryTypes()),
+        generatedFile('src/validators.ts', renderValidators()),
+        generatedFile('src/sqlite.ts', renderSqliteAdapter(project, resolved)),
+        generatedFile('migrations/0001_initial.sql', renderInitialMigration(project.resources)),
+        generatedFile('README.md', renderReadme(project, resolved)),
+    ];
+    if (resolved.seed === 'fixtures') {
+        files.push(generatedFile('src/seed.ts', renderSeedModule()));
+    }
+    if (resolved.api.includes('rest')) {
+        files.push(generatedFile('src/rest.ts', renderRestRoutes()));
+    }
+    if (resolved.api.includes('graphql')) {
+        files.push(generatedFile('src/graphql.ts', renderGraphqlRoutes(project)));
+    }
+    if (resolved.api.length > 0) {
+        files.push(generatedFile('src/app.ts', renderHonoApp(resolved)));
+    }
+    if (resolved.app === 'standalone') {
+        files.push(generatedFile('src/server.ts', renderServerEntry()), generatedFile('package.json', renderPackageJson(resolved)), generatedFile('tsconfig.json', renderTsconfig()));
+    }
+    return files;
+}
+function resolveGenerateOptions(config, options) {
+    const fromConfig = config.generate?.hono ?? {};
+    const definedOptions = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+    const merged = {
+        ...DEFAULT_OPTIONS,
+        ...fromConfig,
+        ...definedOptions,
+    };
+    merged.api = normalizeApi(merged.api);
+    merged.outDir = path.resolve(config.cwd, merged.outDir ?? merged.out ?? DEFAULT_OPTIONS.outDir);
+    merged.db = merged.db ?? 'sqlite';
+    merged.app = merged.app ?? 'standalone';
+    merged.runtime = merged.runtime ?? 'node-sqlite';
+    merged.seed = merged.seed === true ? 'fixtures' : merged.seed;
+    if (merged.db !== 'sqlite') {
+        throw dbError('GENERATE_UNSUPPORTED_DB', `Unsupported generated database "${merged.db}".`, {
+            hint: 'Use --db sqlite for the v1 generator.',
+            details: {
+                db: merged.db,
+            },
+        });
+    }
+    if (!['standalone', 'module'].includes(merged.app)) {
+        throw dbError('GENERATE_UNSUPPORTED_APP_SHAPE', `Unsupported generated app shape "${merged.app}".`, {
+            hint: 'Use --app standalone or --app module.',
+            details: {
+                app: merged.app,
+            },
+        });
+    }
+    return merged;
+}
+function normalizeApi(value) {
+    const raw = Array.isArray(value) ? value : String(value ?? 'rest').split(',');
+    const api = raw.map((item) => String(item).trim()).filter(Boolean);
+    if (api.length === 1 && api[0] === 'none') {
+        return [];
+    }
+    const unsupported = api.filter((item) => !['rest', 'graphql'].includes(item));
+    if (unsupported.length > 0) {
+        throw dbError('GENERATE_UNSUPPORTED_API', `Unsupported generated API target "${unsupported[0]}".`, {
+            hint: 'Use --api rest, --api graphql, --api rest,graphql, or --api none.',
+            details: {
+                api,
+            },
+        });
+    }
+    return [...new Set(api)];
+}
+function assertGeneratable(project, options) {
+    const errors = project.diagnostics.filter((diagnostic) => diagnostic.severity === 'error');
+    const warnings = project.diagnostics.filter((diagnostic) => diagnostic.severity === 'warn');
+    const blocking = options.allowWarnings ? errors : [...errors, ...warnings];
+    if (blocking.length === 0) {
+        return;
+    }
+    const error = dbError('GENERATE_SCHEMA_DIAGNOSTICS', `Cannot generate Hono starter because schema diagnostics are present: ${blocking[0].message}`, {
+        hint: options.allowWarnings
+            ? 'Fix schema errors before generating production starter code.'
+            : 'Fix schema warnings/errors, or pass --allow-warnings to generate while keeping warning diagnostics.',
+        details: {
+            diagnostics: blocking,
+        },
+    });
+    error.diagnostics = blocking;
+    throw error;
+}
+function generatedFile(filePath, content) {
+    return {
+        path: filePath,
+        content: content.endsWith('\n') ? content : `${content}\n`,
+    };
+}

package/dist/generate/hono/package.d.ts

@@ -0,0 +1,6 @@
+type PackageRenderOptions = {
+    api: string[];
+};
+export declare function renderPackageJson(options: PackageRenderOptions): string;
+export declare function renderTsconfig(): string;
+export {};

package/dist/generate/hono/package.js

@@ -0,0 +1,44 @@
+export function renderPackageJson(options) {
+    const dependencies = {
+        '@hono/node-server': '^1.13.8',
+        hono: '^4.6.0',
+    };
+    if (options.api.includes('graphql')) {
+        dependencies['@async/db'] = '^0.1.0';
+    }
+    return `${JSON.stringify({
+        name: 'db-api',
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'tsx watch src/server.ts',
+            start: 'node dist/server.js',
+            build: 'tsc -p tsconfig.json',
+        },
+        dependencies,
+        devDependencies: {
+            '@types/node': '^22.13.0',
+            tsx: '^4.19.0',
+            typescript: '^5.7.0',
+        },
+        engines: {
+            node: '>=22.13',
+        },
+    }, null, 2)}\n`;
+}
+export function renderTsconfig() {
+    return `${JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            strict: true,
+            esModuleInterop: true,
+            outDir: 'dist',
+            rootDir: 'src',
+            skipLibCheck: true,
+        },
+        include: ['src/**/*.ts'],
+    }, null, 2)}\n`;
+}

package/dist/generate/hono/readme.d.ts

@@ -0,0 +1,13 @@
+type HonoReadmeResource = {
+    name: string;
+    kind: string;
+};
+type HonoReadmeProject = {
+    resources: HonoReadmeResource[];
+};
+type HonoReadmeOptions = {
+    api: string[];
+    seed: unknown;
+};
+export declare function renderReadme(project: HonoReadmeProject, options: HonoReadmeOptions): string;
+export {};

package/dist/generate/hono/readme.js

@@ -0,0 +1,28 @@
+export function renderReadme(project, options) {
+    const apiText = options.api.length === 0 ? 'SQLite repository only' : options.api.join(' + ');
+    return `${generatedHeader()}# db Hono API Starter
+
+Generated from db schema resources:
+
+${project.resources.map((resource) => `- ${resource.name} (${resource.kind})`).join('\n')}
+
+## Shape
+
+- API: ${apiText}
+- Database: SQLite with node:sqlite
+- Runtime: Node.js >=22.13
+- Seed fixtures: ${options.seed === 'fixtures' ? 'enabled' : 'disabled'}
+
+## Commands
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+The initial migration is in \`migrations/0001_initial.sql\`. Destructive schema changes should be reviewed manually.
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono/repository.d.ts

@@ -0,0 +1 @@
+export declare function renderRepositoryTypes(): string;

package/dist/generate/hono/repository.js

@@ -0,0 +1,27 @@
+export function renderRepositoryTypes() {
+    return `${generatedHeader()}
+export type CollectionRepository = {
+  all(): Promise<Record<string, unknown>[]>;
+  get(id: string): Promise<Record<string, unknown> | null>;
+  create(record: Record<string, unknown>): Promise<Record<string, unknown>>;
+  patch(id: string, patch: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+  delete(id: string): Promise<boolean>;
+};
+
+export type DocumentRepository = {
+  all(): Promise<Record<string, unknown>>;
+  put(value: Record<string, unknown>): Promise<Record<string, unknown>>;
+  patch(value: Record<string, unknown>): Promise<Record<string, unknown>>;
+};
+
+export type DbRepository = {
+  resources: Record<string, any>;
+  collection(name: string): CollectionRepository;
+  document(name: string): DocumentRepository;
+  close?(): void;
+};
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono/rest.d.ts

@@ -0,0 +1 @@
+export declare function renderRestRoutes(): string;

package/dist/generate/hono/rest.js

@@ -0,0 +1,38 @@
+export function renderRestRoutes() {
+    return `${generatedHeader()}
+import type { Hono } from 'hono';
+import type { DbRepository } from './repository.js';
+import { resources } from './schema.js';
+
+export function registerDbRoutes(app: Hono, repository: DbRepository) {
+  for (const [resourceName, resource] of Object.entries<any>(resources)) {
+    if (resource.kind === 'collection') {
+      app.get(resource.routePath, async (c) => c.json(await repository.collection(resourceName).all()));
+      app.get(resource.routePath + '/:id', async (c) => {
+        const record = await repository.collection(resourceName).get(c.req.param('id'));
+        return record ? c.json(record) : c.json({ error: 'Not found' }, 404);
+      });
+      app.post(resource.routePath, async (c) => {
+        const record = await repository.collection(resourceName).create(await c.req.json());
+        return c.json(record, 201);
+      });
+      app.patch(resource.routePath + '/:id', async (c) => {
+        const record = await repository.collection(resourceName).patch(c.req.param('id'), await c.req.json());
+        return record ? c.json(record) : c.json({ error: 'Not found' }, 404);
+      });
+      app.delete(resource.routePath + '/:id', async (c) => {
+        const deleted = await repository.collection(resourceName).delete(c.req.param('id'));
+        return deleted ? c.body(null, 204) : c.json({ error: 'Not found' }, 404);
+      });
+    } else {
+      app.get(resource.routePath, async (c) => c.json(await repository.document(resourceName).all()));
+      app.put(resource.routePath, async (c) => c.json(await repository.document(resourceName).put(await c.req.json())));
+      app.patch(resource.routePath, async (c) => c.json(await repository.document(resourceName).patch(await c.req.json())));
+    }
+  }
+}
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono/schema.d.ts

@@ -0,0 +1,13 @@
+type HonoSchemaResource = {
+    name: string;
+    seed?: unknown;
+};
+type HonoSchemaProject = {
+    schema: {
+        resources: unknown;
+    };
+    resources: HonoSchemaResource[];
+};
+export declare function renderGeneratedSchema(project: HonoSchemaProject): string;
+export declare function renderSeedModule(): string;
+export {};