@async/db 0.2.0

package/dist/generate/hono/schema.js

@@ -0,0 +1,18 @@
+export function renderGeneratedSchema(project) {
+    return [
+        generatedHeader(),
+        `export const resources = ${JSON.stringify(project.schema.resources, null, 2)} as const;`,
+        '',
+        `export const seedData = ${JSON.stringify(Object.fromEntries(project.resources.map((resource) => [resource.name, resource.seed])), null, 2)} as const;`,
+        '',
+        'export type ResourceName = keyof typeof resources;',
+    ].join('\n');
+}
+export function renderSeedModule() {
+    return `${generatedHeader()}
+export { seedData } from './schema.js';
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

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

@@ -0,0 +1,20 @@
+type HonoField = {
+    type?: string;
+    required?: boolean;
+    [key: string]: unknown;
+};
+type HonoResource = {
+    name: string;
+    kind: string;
+    idField?: string;
+    fields: Record<string, HonoField>;
+};
+type HonoSqliteProject = {
+    resources: HonoResource[];
+};
+type HonoSqliteOptions = {
+    seed?: unknown;
+};
+export declare function renderSqliteAdapter(project: HonoSqliteProject, options: HonoSqliteOptions): string;
+export declare function renderInitialMigration(resources: HonoResource[]): string;
+export {};

package/dist/generate/hono/sqlite.js

@@ -0,0 +1,266 @@
+export function renderSqliteAdapter(project, options) {
+    const seedImport = options.seed === 'fixtures' ? "import { seedData } from './schema.js';\n" : '';
+    const seedCall = options.seed === 'fixtures' ? '\n  seedFixtures(db);\n' : '';
+    const seedFunction = options.seed === 'fixtures' ? `
+function seedFixtures(db: DatabaseSync) {
+  for (const [resourceName, seed] of Object.entries<any>(seedData)) {
+    const resource = (resources as Record<string, any>)[resourceName];
+    if (!resource) {
+      continue;
+    }
+    if (resource.kind === 'collection') {
+      const count = db.prepare('SELECT COUNT(*) as count FROM ' + quoteIdentifier(resourceName)).get() as { count: number };
+      if (count.count > 0) {
+        continue;
+      }
+      const collection = collectionRepository(db, resourceName);
+      for (const record of seed) {
+        collection.create(record);
+      }
+    } else {
+      const existing = db.prepare('SELECT name FROM _db_documents WHERE name = ?').get(resourceName);
+      if (!existing) {
+        documentRepository(db, resourceName).put(seed);
+      }
+    }
+  }
+}
+` : '';
+    return `${generatedHeader()}
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { resources } from './schema.js';
+${seedImport}import type { CollectionRepository, DocumentRepository, DbRepository } from './repository.js';
+import { applyDefaults, stripUnknownFields, validateRecord } from './validators.js';
+
+export function openSqliteRepository(file = process.env.DATABASE_FILE || './data/app.sqlite'): DbRepository {
+  if (file !== ':memory:') {
+    mkdirSync(path.dirname(file), { recursive: true });
+  }
+  const db = new DatabaseSync(file);
+  migrate(db);${seedCall}
+  return {
+    resources,
+    collection(name: string) {
+      return collectionRepository(db, name);
+    },
+    document(name: string) {
+      return documentRepository(db, name);
+    },
+    close() {
+      db.close();
+    },
+  };
+}
+
+export function migrate(db: DatabaseSync) {
+${renderMigrationExecLines(project.resources)}
+}
+
+function collectionRepository(db: DatabaseSync, resourceName: string): CollectionRepository {
+  const resource = requireResource(resourceName, 'collection');
+  const table = quoteIdentifier(resource.name);
+  const fields = Object.keys(resource.fields);
+  const idField = resource.idField || 'id';
+
+  return {
+    async all() {
+      return (db.prepare('SELECT * FROM ' + table).all() as Record<string, unknown>[]).map((row) => deserializeRow(resourceName, row));
+    },
+    async get(id) {
+      const row = db.prepare('SELECT * FROM ' + table + ' WHERE ' + quoteIdentifier(idField) + ' = ?').get(String(id)) as Record<string, unknown> | undefined;
+      return row ? deserializeRow(resourceName, row) : null;
+    },
+    async create(record) {
+      const next = applyDefaults(resourceName, stripUnknownFields(resourceName, { ...record }));
+      if (next[idField] === undefined || next[idField] === null || next[idField] === '') {
+        next[idField] = nextId(db, table, idField);
+      }
+      validateRecord(resourceName, next);
+      const serialized = serializeRow(resourceName, next);
+      const columns = fields.map(quoteIdentifier).join(', ');
+      const placeholders = fields.map(() => '?').join(', ');
+      db.prepare('INSERT INTO ' + table + ' (' + columns + ') VALUES (' + placeholders + ')').run(...fields.map((field) => serialized[field] ?? null));
+      return next;
+    },
+    async patch(id, patch) {
+      const existing = await this.get(id);
+      if (!existing) {
+        return null;
+      }
+      const next = stripUnknownFields(resourceName, { ...existing, ...patch, [idField]: existing[idField] });
+      validateRecord(resourceName, next);
+      const serialized = serializeRow(resourceName, next);
+      const updateFields = fields.filter((field) => field !== idField);
+      const assignments = updateFields.map((field) => quoteIdentifier(field) + ' = ?').join(', ');
+      db.prepare('UPDATE ' + table + ' SET ' + assignments + ' WHERE ' + quoteIdentifier(idField) + ' = ?').run(...updateFields.map((field) => serialized[field] ?? null), String(id));
+      return next;
+    },
+    async delete(id) {
+      const result = db.prepare('DELETE FROM ' + table + ' WHERE ' + quoteIdentifier(idField) + ' = ?').run(String(id));
+      return result.changes > 0;
+    },
+  };
+}
+
+function documentRepository(db: DatabaseSync, resourceName: string): DocumentRepository {
+  const resource = requireResource(resourceName, 'document');
+  return {
+    async all() {
+      const row = db.prepare('SELECT value FROM _db_documents WHERE name = ?').get(resource.name) as { value: string } | undefined;
+      return row ? JSON.parse(row.value) : {};
+    },
+    async put(value) {
+      const next = stripUnknownFields(resourceName, value);
+      validateRecord(resourceName, next);
+      db.prepare('INSERT INTO _db_documents (name, value) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET value = excluded.value').run(resource.name, JSON.stringify(next));
+      return next;
+    },
+    async patch(value) {
+      const existing = await this.all();
+      return this.put({ ...existing, ...value });
+    },
+  };
+}
+
+function serializeRow(resourceName: string, record: Record<string, unknown>) {
+  const resource = requireResource(resourceName, 'collection');
+  const row: Record<string, unknown> = {};
+  for (const [fieldName, field] of Object.entries<any>(resource.fields)) {
+    const value = record[fieldName];
+    if (value === undefined) {
+      row[fieldName] = null;
+    } else if (field.type === 'boolean') {
+      row[fieldName] = value ? 1 : 0;
+    } else if (field.type === 'object' || field.type === 'array' || field.type === 'unknown') {
+      row[fieldName] = JSON.stringify(value);
+    } else {
+      row[fieldName] = value;
+    }
+  }
+  return row;
+}
+
+function deserializeRow(resourceName: string, row: Record<string, unknown>) {
+  const resource = requireResource(resourceName, 'collection');
+  const record: Record<string, unknown> = {};
+  for (const [fieldName, field] of Object.entries<any>(resource.fields)) {
+    const value = row[fieldName];
+    if (value === null || value === undefined) {
+      continue;
+    }
+    if (field.type === 'boolean') {
+      record[fieldName] = Boolean(value);
+    } else if (field.type === 'object' || field.type === 'array' || field.type === 'unknown') {
+      record[fieldName] = typeof value === 'string' ? JSON.parse(value) : value;
+    } else {
+      record[fieldName] = value;
+    }
+  }
+  return record;
+}
+
+function nextId(db: DatabaseSync, table: string, idField: string) {
+  const rows = db.prepare('SELECT ' + quoteIdentifier(idField) + ' as id FROM ' + table).all() as Array<{ id: string }>;
+  const ids = rows.map((row) => String(row.id)).filter(Boolean);
+  const numeric = ids.map((id) => Number(id)).filter((id) => Number.isInteger(id) && id > 0);
+  let next = numeric.length > 0 ? Math.max(...numeric) + 1 : ids.length + 1;
+  while (ids.includes(String(next))) {
+    next += 1;
+  }
+  return String(next);
+}
+
+function requireResource(resourceName: string, kind: 'collection' | 'document') {
+  const resource = resolveResource(resourceName);
+  if (!resource || resource.kind !== kind) {
+    throw new Error('Unknown ' + kind + ' resource "' + resourceName + '". Tried: ' + resourceNameCandidates(resourceName).join(', ') + '.');
+  }
+  return resource;
+}
+
+function resolveResource(resourceName: string) {
+  for (const candidate of resourceNameCandidates(resourceName)) {
+    const resource = (resources as Record<string, any>)[candidate];
+    if (resource) {
+      return resource;
+    }
+  }
+  return null;
+}
+
+function resourceNameCandidates(value: string) {
+  const exact = String(value);
+  return [...new Set([exact, camelCase(exact), kebabCase(exact)])];
+}
+
+function camelCase(value: string) {
+  return words(value).map((word, index) => (
+    index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
+  )).join('');
+}
+
+function kebabCase(value: string) {
+  return words(value).join('-');
+}
+
+function words(value: string) {
+  return String(value)
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part.toLowerCase());
+}
+
+function quoteIdentifier(value: string) {
+  return '"' + String(value).replaceAll('"', '""') + '"';
+}
+${seedFunction}`;
+}
+export function renderInitialMigration(resources) {
+    return `${generatedHeader('--')}${resources.map((resource) => (resource.kind === 'collection'
+        ? createTableSql(resource)
+        : null)).filter(Boolean).join('\n\n')}
+
+CREATE TABLE IF NOT EXISTS "_db_documents" (
+  "name" TEXT PRIMARY KEY,
+  "value" TEXT NOT NULL
+) STRICT;
+`;
+}
+function renderMigrationExecLines(resources) {
+    const sql = renderInitialMigration(resources).split('\n').filter((line) => !line.startsWith('--')).join('\n');
+    return `  db.exec(${JSON.stringify(sql)});`;
+}
+function createTableSql(resource) {
+    const columns = Object.entries(resource.fields).map(([fieldName, field]) => {
+        const type = sqliteTypeForField(field);
+        const primary = fieldName === resource.idField ? ' PRIMARY KEY' : '';
+        const required = field.required && fieldName !== resource.idField ? ' NOT NULL' : '';
+        return `  ${quoteIdentifier(fieldName)} ${type}${primary}${required}`;
+    });
+    return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(resource.name)} (\n${columns.join(',\n')}\n) STRICT;`;
+}
+function sqliteTypeForField(field) {
+    switch (field.type) {
+        case 'number':
+            return 'REAL';
+        case 'boolean':
+            return 'INTEGER';
+        case 'object':
+        case 'array':
+        case 'unknown':
+            return 'TEXT';
+        case 'string':
+        case 'enum':
+        default:
+            return 'TEXT';
+    }
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}
+function quoteIdentifier(value) {
+    return `"${String(value).replaceAll('"', '""')}"`;
+}

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

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

package/dist/generate/hono/validators.js

@@ -0,0 +1,141 @@
+export function renderValidators() {
+    return `${generatedHeader()}
+import { resources } from './schema.js';
+
+export function applyDefaults(resourceName: string, value: Record<string, unknown>) {
+  const resource = requireResource(resourceName);
+  const next = { ...value };
+  for (const [fieldName, field] of Object.entries<any>(resource.fields || {})) {
+    if (next[fieldName] === undefined && 'default' in field) {
+      next[fieldName] = structuredClone(field.default);
+    }
+  }
+  return next;
+}
+
+export function stripUnknownFields(resourceName: string, value: Record<string, unknown>) {
+  const resource = requireResource(resourceName);
+  const next: Record<string, unknown> = {};
+  for (const fieldName of Object.keys(resource.fields || {})) {
+    if (value[fieldName] !== undefined) {
+      next[fieldName] = value[fieldName];
+    }
+  }
+  return next;
+}
+
+export function validateRecord(resourceName: string, value: Record<string, unknown>) {
+  const resource = requireResource(resourceName);
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw validationError(resourceName, 'Record must be a JSON object.');
+  }
+
+  for (const [fieldName, field] of Object.entries<any>(resource.fields || {})) {
+    const fieldValue = value[fieldName];
+    if (field.required && (fieldValue === undefined || (fieldValue === null && !field.nullable))) {
+      throw validationError(resourceName, 'Missing required field "' + fieldName + '".');
+    }
+    if (fieldValue !== undefined) {
+      validateValue(resourceName, fieldName, field, fieldValue);
+    }
+  }
+}
+
+function validateValue(resourceName: string, fieldPath: string, field: any, value: unknown) {
+  if (value === null && field.type !== 'unknown' && !field.nullable) {
+    throw validationError(resourceName, 'Field "' + fieldPath + '" cannot be null.');
+  }
+
+  if (value === null) {
+    return;
+  }
+
+  if (field.type === 'unknown') {
+    return;
+  }
+  if ((field.type === 'string' || field.type === 'datetime') && typeof value !== 'string') {
+    throw validationError(resourceName, 'Field "' + fieldPath + '" must be a string.');
+  }
+  if (field.type === 'number' && (typeof value !== 'number' || !Number.isFinite(value))) {
+    throw validationError(resourceName, 'Field "' + fieldPath + '" must be a finite number.');
+  }
+  if (field.type === 'boolean' && typeof value !== 'boolean') {
+    throw validationError(resourceName, 'Field "' + fieldPath + '" must be a boolean.');
+  }
+  if (field.type === 'enum' && !field.values?.includes(value)) {
+    throw validationError(resourceName, 'Field "' + fieldPath + '" must be one of: ' + (field.values || []).join(', ') + '.');
+  }
+  if (field.type === 'array') {
+    if (!Array.isArray(value)) {
+      throw validationError(resourceName, 'Field "' + fieldPath + '" must be an array.');
+    }
+    value.forEach((item, index) => validateValue(resourceName, fieldPath + '[' + index + ']', field.items || { type: 'unknown' }, item));
+  }
+  if (field.type === 'object') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      throw validationError(resourceName, 'Field "' + fieldPath + '" must be an object.');
+    }
+    for (const [childName, childField] of Object.entries<any>(field.fields || {})) {
+      const childValue = (value as Record<string, unknown>)[childName];
+      if (childField.required && (childValue === undefined || (childValue === null && !childField.nullable))) {
+        throw validationError(resourceName, 'Missing required field "' + fieldPath + '.' + childName + '".');
+      }
+      if (childValue !== undefined) {
+        validateValue(resourceName, fieldPath + '.' + childName, childField, childValue);
+      }
+    }
+  }
+}
+
+function requireResource(resourceName: string) {
+  const resource = resolveResource(resourceName);
+  if (!resource) {
+    throw validationError(resourceName, 'Unknown resource "' + resourceName + '". Tried: ' + resourceNameCandidates(resourceName).join(', ') + '.');
+  }
+  return resource;
+}
+
+function resolveResource(resourceName: string) {
+  for (const candidate of resourceNameCandidates(resourceName)) {
+    const resource = (resources as Record<string, any>)[candidate];
+    if (resource) {
+      return resource;
+    }
+  }
+  return null;
+}
+
+function resourceNameCandidates(value: string) {
+  const exact = String(value);
+  return [...new Set([exact, camelCase(exact), kebabCase(exact)])];
+}
+
+function camelCase(value: string) {
+  return words(value).map((word, index) => (
+    index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
+  )).join('');
+}
+
+function kebabCase(value: string) {
+  return words(value).join('-');
+}
+
+function words(value: string) {
+  return String(value)
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part.toLowerCase());
+}
+
+function validationError(resourceName: string, message: string) {
+  const error = new Error(resourceName + ': ' + message) as Error & { status?: number; code?: string };
+  error.status = 400;
+  error.code = 'VALIDATION_FAILED';
+  return error;
+}
+`;
+}
+function generatedHeader(comment = '//') {
+    return `${comment} This file is generated by db. Edit it freely after generation.\n`;
+}

package/dist/generate/hono.d.ts

@@ -0,0 +1 @@
+export { generateHonoStarter, renderHonoStarter } from './hono/index.js';

package/dist/generate/hono.js

@@ -0,0 +1 @@
+export { generateHonoStarter, renderHonoStarter } from './hono/index.js';

package/dist/graphql/execute.d.ts

@@ -0,0 +1,14 @@
+type GraphqlVariables = Record<string, unknown>;
+type GraphqlRequest = string | {
+    query?: string;
+    variables?: GraphqlVariables;
+    operationName?: string | null;
+};
+type GraphqlResult = {
+    data: unknown;
+    errors?: unknown[];
+};
+type GraphqlDb = Record<string, any>;
+export declare function executeGraphql(db: GraphqlDb, request: GraphqlRequest | GraphqlRequest[]): Promise<GraphqlResult | GraphqlResult[]>;
+export declare function executeGraphqlBatch(db: GraphqlDb, requests: GraphqlRequest[]): Promise<GraphqlResult[]>;
+export {};