@nanokajs/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,366 @@
+import { D1Database } from '@cloudflare/workers-types';
+import { BatchItem, BatchResponse } from 'drizzle-orm/batch';
+import { BaseSQLiteDatabase, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { F as Field, I as InferFieldType } from './factories-CDsk1Hdt.js';
+export { a as FieldModifiers, t } from './factories-CDsk1Hdt.js';
+import { Hook } from '@hono/zod-validator';
+import * as hono from 'hono';
+import { ValidationTargets, Env, MiddlewareHandler, Hono } from 'hono';
+import { z } from 'zod';
+
+/**
+ * Generic database adapter abstraction for SQLite-compatible databases.
+ *
+ * Permits implementations over D1, Turso/libSQL, and other SQLite-compatible backends
+ * without requiring changes to core query path or router.
+ *
+ * The `drizzle` property deliberately exposes the raw Drizzle database instance,
+ * adhering to rule #4 (escape hatch always open).
+ *
+ * The `TResultKind` generic is intentionally constrained to `any` to avoid
+ * coupling adapter implementations to Drizzle's internal result kind type.
+ */
+interface Adapter<TSchema extends Record<string, unknown> = Record<string, never>> {
+    readonly drizzle: BaseSQLiteDatabase<'async', any, TSchema>;
+    /**
+     * Executes multiple Drizzle queries in a single batch.
+     * Returns results in the same order as the input.
+     *
+     * **重要**: 実装は `this` 非依存であること（`nanoka()` 内で thin wrapper として再公開されるため、
+     * `this` バインディングが失われた状態で呼び出される可能性がある）。
+     */
+    batch<U extends BatchItem<'sqlite'>, T extends readonly [U, ...U[]]>(queries: T): Promise<BatchResponse<T>>;
+}
+
+/**
+ * D1-specific adapter factory. Wraps Cloudflare D1 binding in the generic
+ * Adapter abstraction, enabling the core query path and router to remain
+ * implementation-agnostic.
+ */
+declare function d1Adapter<TSchema extends Record<string, unknown> = Record<string, never>>(d1: D1Database): Adapter<TSchema>;
+
+/**
+ * Options for findMany query.
+ * `limit` is required (no default).
+ * `offset` defaults to 0 if omitted.
+ * `orderBy` is optional for column ordering.
+ */
+interface FindManyOptions<Fields extends Record<string, Field<any, any, any>>> {
+    readonly limit: number;
+    readonly offset?: number;
+    readonly orderBy?: OrderBy<Fields>;
+}
+/**
+ * Order-by specification: single field, or field with direction, or array of multiple.
+ */
+type OrderBy<Fields extends Record<string, Field<any, any, any>>> = (keyof Fields & string) | {
+    readonly column: keyof Fields & string;
+    readonly direction?: 'asc' | 'desc';
+} | ReadonlyArray<(keyof Fields & string) | {
+    readonly column: keyof Fields & string;
+    readonly direction?: 'asc' | 'desc';
+}>;
+/**
+ * Where clause object: each key is a field name, each value is the desired equality.
+ */
+type Where<Fields extends Record<string, Field<any, any, any>>> = {
+    readonly [K in keyof Fields]?: InferFieldType<Fields[K]>;
+};
+/**
+ * Identifier or Where clause: can be a primary key value or a Where object.
+ */
+type IdOrWhere<Fields extends Record<string, Field<any, any, any>>> = string | number | Where<Fields>;
+/**
+ * Row type: full record type from fields.
+ */
+type RowType<Fields extends Record<string, Field<any, any, any>>> = {
+    [K in keyof Fields]: InferFieldType<Fields[K]>;
+};
+/**
+ * Create input: partial row (most fields optional for insert).
+ * Phase 1 では `Partial<RowType>` のままとし、必須/任意フィールドの型区別は Phase 2 で扱う。
+ */
+type CreateInput<Fields extends Record<string, Field<any, any, any>>> = Partial<RowType<Fields>>;
+interface SchemaOptions<K extends string = string> {
+    readonly pick?: readonly K[];
+    readonly omit?: readonly K[];
+    readonly partial?: boolean;
+}
+/**
+ * @internal
+ * Extracts a Zod shape from fields for the Apply type.
+ * Each field's zodBase becomes a property in the shape.
+ * Indexed access ensures concrete Zod types are preserved (not `any`).
+ */
+type FieldsToZodShape<Fields extends Record<string, Field<any, any, any>>> = {
+    [K in keyof Fields]: Fields[K]['zodBase'];
+};
+/**
+ * @internal
+ * Utility to narrow array literal types to union of strings.
+ */
+type ArrayKeys<A> = A extends readonly (infer U)[] ? U : never;
+/**
+ * @internal
+ * Apply pick transformation to a shape.
+ */
+type ApplyPickToShape<Shape extends z.ZodRawShape, PickKeys> = PickKeys extends readonly string[] ? Pick<Shape, ArrayKeys<PickKeys> & keyof Shape> : Shape;
+/**
+ * @internal
+ * Apply omit transformation to a shape.
+ */
+type ApplyOmitToShape<Shape extends z.ZodRawShape, OmitKeys> = OmitKeys extends readonly string[] ? Omit<Shape, ArrayKeys<OmitKeys> & keyof Shape> : Shape;
+/**
+ * @internal
+ * Apply partial transformation to a shape.
+ */
+type ApplyPartialToShape<Shape extends z.ZodRawShape> = {
+    [K in keyof Shape]: z.ZodOptional<Shape[K]>;
+};
+/**
+ * @internal
+ * Apply pick/omit/partial transformations to a Zod raw shape.
+ * Order: pick → omit → partial
+ */
+type ApplyShape<Shape extends z.ZodRawShape, Opts extends SchemaOptions | undefined> = Opts extends undefined ? Shape : Opts extends {
+    pick: readonly string[];
+} ? Opts extends {
+    omit: readonly string[];
+} ? Opts extends {
+    partial: true;
+} ? ApplyPartialToShape<ApplyOmitToShape<ApplyPickToShape<Shape, Opts['pick']>, Opts['omit']>> : ApplyOmitToShape<ApplyPickToShape<Shape, Opts['pick']>, Opts['omit']> : Opts extends {
+    partial: true;
+} ? ApplyPartialToShape<ApplyPickToShape<Shape, Opts['pick']>> : ApplyPickToShape<Shape, Opts['pick']> : Opts extends {
+    omit: readonly string[];
+} ? Opts extends {
+    partial: true;
+} ? ApplyPartialToShape<ApplyOmitToShape<Shape, Opts['omit']>> : ApplyOmitToShape<Shape, Opts['omit']> : Opts extends {
+    partial: true;
+} ? ApplyPartialToShape<Shape> : Shape;
+/**
+ * @internal
+ * Returns the correct Zod object type after applying pick/omit/partial transformations.
+ */
+type Apply<Shape extends z.ZodRawShape, Opts extends SchemaOptions | undefined> = z.ZodObject<ApplyShape<Shape, Opts>>;
+/**
+ * @internal
+ * Mirrors @hono/zod-validator's middleware Input type.
+ * Aligned with @hono/zod-validator@0.4.x; revisit on version bump.
+ */
+type HasUndefined<T> = undefined extends T ? true : false;
+type ValidatorInput<Target extends keyof ValidationTargets, Schema extends z.ZodType<any, z.ZodTypeDef, any>, In = z.input<Schema>, Out = z.output<Schema>> = {
+    in: HasUndefined<In> extends true ? {
+        [K in Target]?: (In extends ValidationTargets[K] ? In : {
+            [K2 in keyof In]?: ValidationTargets[K][K2] | undefined;
+        }) | undefined;
+    } : {
+        [K in Target]: In extends ValidationTargets[K] ? In : {
+            [K2 in keyof In]: ValidationTargets[K][K2];
+        };
+    };
+    out: {
+        [K in Target]: Out;
+    };
+};
+/**
+ * @internal
+ * Type-safe Hono middleware handler return for Model.validator().
+ * Provides proper type narrowing for c.req.valid(target).
+ */
+type ModelValidatorReturn<Fields extends Record<string, Field<any, any, any>>, Target extends keyof ValidationTargets, Opts extends SchemaOptions<keyof Fields & string> | undefined> = MiddlewareHandler<any, string, ValidatorInput<Target, Apply<FieldsToZodShape<Fields>, Opts>>>;
+
+/**
+ * Represents a database model with type-safe schema derivation and CRUD operations.
+ */
+interface Model<Fields extends Record<string, Field<any, any, any>>> {
+    readonly fields: Fields;
+    readonly tableName: string;
+    readonly table: SQLiteTable;
+    /**
+     * Returns a Zod schema derived from this model's fields.
+     * Supports pick, omit, and partial transformations.
+     *
+     * @example
+     * const CreateSchema = User.schema({ omit: ['passwordHash'] })
+     * const UpdateSchema = User.schema({ partial: true, pick: ['name', 'email'] })
+     */
+    schema<Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined>(opts?: Opts): Apply<FieldsToZodShape<Fields>, Opts>;
+    /**
+     * Returns a Hono middleware validator derived from this model's schema.
+     * Integrates with @hono/zod-validator to validate request inputs.
+     * The optional `hook` argument is passed through to @hono/zod-validator.
+     *
+     * @example
+     * app.post('/users', User.validator('json', { omit: ['passwordHash'] }), c => {
+     *   const body = c.req.valid('json')
+     * })
+     * // With hook for hardened error responses:
+     * app.post('/users', User.validator('json', opts, (result, c) => {
+     *   if (!result.success) return c.json({ error: 'Invalid request' }, 400)
+     * }), handler)
+     */
+    validator<Target extends keyof ValidationTargets, Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined, E extends Env = Env, P extends string = string>(target: Target, opts?: Opts, hook?: Hook<z.output<Apply<FieldsToZodShape<Fields>, Opts>>, E, P, Target>): ModelValidatorReturn<Fields, Target, Opts>;
+    /**
+     * Fetches multiple rows with pagination and optional ordering.
+     * `limit` is required (no default) to prevent accidental unbounded queries.
+     * Offset defaults to 0 if omitted.
+     *
+     * @example
+     * const users = await User.findMany(adapter, { limit: 20 })
+     * const page2 = await User.findMany(adapter, { limit: 20, offset: 20 })
+     * const sorted = await User.findMany(adapter, { limit: 10, orderBy: 'name' })
+     */
+    findMany(adapter: Adapter, options: FindManyOptions<Fields>): Promise<RowType<Fields>[]>;
+    /**
+     * Fetches a single row by primary key or where clause.
+     * Returns null if not found.
+     *
+     * @example
+     * const user = await User.findOne(adapter, id)
+     * const byEmail = await User.findOne(adapter, { email: 'john@example.com' })
+     */
+    findOne(adapter: Adapter, idOrWhere: IdOrWhere<Fields>): Promise<RowType<Fields> | null>;
+    /**
+     * Creates a new row and returns the created record.
+     *
+     * @example
+     * const user = await User.create(adapter, { name: 'John', email: 'john@example.com' })
+     */
+    create(adapter: Adapter, data: CreateInput<Fields>): Promise<RowType<Fields>>;
+    /**
+     * Updates rows matching the given id or where clause.
+     * Returns the updated row(s), or null if no rows matched.
+     *
+     * @example
+     * const updated = await User.update(adapter, id, { name: 'Jane' })
+     * const byEmail = await User.update(adapter, { email: '...' }, { name: 'Jane' })
+     */
+    update(adapter: Adapter, idOrWhere: IdOrWhere<Fields>, data: Partial<RowType<Fields>>): Promise<RowType<Fields> | null>;
+    /**
+     * Deletes rows matching the given id or where clause.
+     * Returns the number of deleted rows.
+     *
+     * @example
+     * const result = await User.delete(adapter, id)
+     * console.log(result.deleted) // number
+     */
+    delete(adapter: Adapter, idOrWhere: IdOrWhere<Fields>): Promise<{
+        readonly deleted: number;
+    }>;
+}
+
+/**
+ * Creates a Model instance from a tableName and fields definition.
+ * The model supports deriving Zod schemas, Hono validators, and CRUD operations.
+ *
+ * @example
+ * const User = defineModel('users', {
+ *   id: t.uuid().primary(),
+ *   name: t.string(),
+ *   email: t.string().email(),
+ *   passwordHash: t.string(),
+ * })
+ *
+ * const CreateSchema = User.schema({ omit: ['passwordHash'] })
+ * const users = await User.findMany(adapter, { limit: 20 })
+ */
+declare function defineModel<Fields extends Record<string, Field<any, any, any>>>(tableName: string, fields: Fields): Model<Fields>;
+
+/**
+ * A model registered in a Nanoka application.
+ * Wraps Model<Fields> with adapter binding, so CRUD methods do not require
+ * passing the adapter each time.
+ *
+ * @template Fields - The field definitions of this model
+ */
+interface NanokaModel<Fields extends Record<string, Field<any, any, any>>> {
+    readonly fields: Fields;
+    readonly tableName: string;
+    readonly table: SQLiteTable;
+    /**
+     * Returns a Zod schema derived from this model's fields.
+     * Supports pick, omit, and partial transformations.
+     */
+    schema<Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined>(opts?: Opts): Apply<FieldsToZodShape<Fields>, Opts>;
+    /**
+     * Returns a Hono middleware validator for this model.
+     * The optional `hook` argument is passed through to @hono/zod-validator.
+     */
+    validator<Target extends keyof hono.ValidationTargets, Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined, E extends Env = Env, P extends string = string>(target: Target, opts?: Opts, hook?: Hook<z.output<Apply<FieldsToZodShape<Fields>, Opts>>, E, P, Target>): ModelValidatorReturn<Fields, Target, Opts>;
+    /**
+     * Fetches multiple rows with pagination and optional ordering.
+     * `limit` is required (no default) to prevent accidental unbounded queries.
+     */
+    findMany(options: FindManyOptions<Fields>): Promise<RowType<Fields>[]>;
+    /**
+     * Fetches a single row by primary key or where clause.
+     * Returns null if not found.
+     */
+    findOne(idOrWhere: IdOrWhere<Fields>): Promise<RowType<Fields> | null>;
+    /**
+     * Creates a new row and returns the created record.
+     */
+    create(data: CreateInput<Fields>): Promise<RowType<Fields>>;
+    /**
+     * Updates rows matching the given id or where clause.
+     * Returns the updated row, or null if no rows matched.
+     */
+    update(idOrWhere: IdOrWhere<Fields>, data: Partial<RowType<Fields>>): Promise<RowType<Fields> | null>;
+    /**
+     * Deletes rows matching the given id or where clause.
+     * Returns the number of deleted rows.
+     */
+    delete(idOrWhere: IdOrWhere<Fields>): Promise<{
+        readonly deleted: number;
+    }>;
+}
+/**
+ * Nanoka application: a Hono instance extended with model registration,
+ * adapter binding, and escape hatches for raw Drizzle and batch operations.
+ */
+interface Nanoka extends Hono {
+    /**
+     * Raw Drizzle database instance (escape hatch per rule #4).
+     * Exposes the full Drizzle API for advanced queries.
+     */
+    readonly db: Adapter['drizzle'];
+    /**
+     * Batch execution API (transactions = D1 batch, per rule #7).
+     * Executes multiple queries in a single D1 batch request.
+     * No bespoke transaction abstraction is provided; batch is a first-class API.
+     */
+    batch: Adapter['batch'];
+    /**
+     * Registers a new model in this application with adapter binding.
+     * Returns a NanokaModel<Fields> with CRUD methods pre-bound to the adapter.
+     *
+     * @example
+     * const app = nanoka(d1Adapter(env.DB))
+     * const User = app.model('users', { id, name, email, passwordHash })
+     * const users = await User.findMany({ limit: 20 })
+     */
+    model<Fields extends Record<string, Field<any, any, any>>>(name: string, fields: Fields): NanokaModel<Fields>;
+}
+
+/**
+ * Creates a Nanoka application instance with the given database adapter.
+ *
+ * @param adapter - The database adapter (e.g., d1Adapter(env.DB))
+ * @returns A Nanoka application (Hono extended with model(), db, and batch)
+ *
+ * @example
+ * export default {
+ *   fetch(req: Request, env: Env, ctx: ExecutionContext) {
+ *     const app = nanoka(d1Adapter(env.DB))
+ *     const User = app.model('users', { id, name, email, passwordHash })
+ *     app.get('/users', async (c) => {
+ *       const users = await User.findMany({ limit: 20 })
+ *       return c.json(users)
+ *     })
+ *     return app.fetch(req, env, ctx)
+ *   }
+ * }
+ */
+declare function nanoka(adapter: Adapter): Nanoka;
+
+export { type Adapter, type CreateInput, Field, type FindManyOptions, type IdOrWhere, InferFieldType, type Model, type Nanoka, type NanokaModel, type OrderBy, type RowType, type SchemaOptions, type Where, d1Adapter, defineModel, nanoka };

package/dist/index.js

@@ -0,0 +1,268 @@
+export { t } from './chunk-F5OBRXXY.js';
+import { drizzle } from 'drizzle-orm/d1';
+import { zValidator } from '@hono/zod-validator';
+import { asc, desc, eq, and } from 'drizzle-orm';
+import { HTTPException } from 'hono/http-exception';
+import { z } from 'zod';
+import { sqliteTable } from 'drizzle-orm/sqlite-core';
+import { Hono } from 'hono';
+
+function d1Adapter(d1) {
+  const db = drizzle(d1);
+  return {
+    drizzle: db,
+    batch: (queries) => db.batch(queries)
+  };
+}
+var MAX_LIMIT = 100;
+function guardLimit(limit) {
+  if (!Number.isInteger(limit)) {
+    throw new HTTPException(400, { message: "limit must be an integer" });
+  }
+  const n = limit;
+  if (n < 0) {
+    throw new HTTPException(400, { message: "limit must be >= 0" });
+  }
+  if (n > MAX_LIMIT) {
+    throw new HTTPException(400, { message: `limit must be <= ${MAX_LIMIT}` });
+  }
+  return n;
+}
+function guardOffset(offset) {
+  if (!Number.isInteger(offset)) {
+    throw new HTTPException(400, { message: "offset must be an integer" });
+  }
+  const n = offset;
+  if (n < 0) {
+    throw new HTTPException(400, { message: "offset must be >= 0" });
+  }
+  return n;
+}
+function findPrimaryKey(fields) {
+  let pkCount = 0;
+  let pkKey = null;
+  let pkField = null;
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.modifiers.primary === true) {
+      pkCount++;
+      if (pkCount === 1) {
+        pkKey = key;
+        pkField = field;
+      }
+    }
+  }
+  if (pkCount === 0) {
+    return null;
+  }
+  if (pkCount > 1) {
+    throw new HTTPException(500, { message: "model has multiple primary keys" });
+  }
+  return [pkKey, pkField];
+}
+function buildWhereClause(table, fields, where) {
+  const conditions = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (!Object.hasOwn(fields, key)) {
+      throw new HTTPException(400, { message: "invalid field in where clause" });
+    }
+    if (!Object.hasOwn(table, key)) {
+      throw new HTTPException(400, { message: "invalid column in table" });
+    }
+    const col = table[key];
+    conditions.push(eq(col, value));
+  }
+  if (conditions.length === 0) {
+    return null;
+  }
+  if (conditions.length === 1) {
+    return conditions[0];
+  }
+  return and(...conditions);
+}
+async function findManyImpl(adapter, table, fields, options) {
+  const limit = guardLimit(options.limit);
+  const offset = options.offset !== void 0 ? guardOffset(options.offset) : 0;
+  let query = adapter.drizzle.select().from(table).limit(limit).offset(offset);
+  if (options.orderBy !== void 0) {
+    const orderByList = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+    for (const orderByItem of orderByList) {
+      let column;
+      let direction = "asc";
+      if (typeof orderByItem === "string") {
+        column = orderByItem;
+      } else if (typeof orderByItem === "object" && orderByItem !== null && "column" in orderByItem) {
+        column = orderByItem.column;
+        if (orderByItem.direction) {
+          direction = orderByItem.direction;
+        }
+      } else {
+        throw new HTTPException(400, { message: "invalid orderBy format" });
+      }
+      if (!Object.hasOwn(table, column)) {
+        throw new HTTPException(400, { message: "invalid field in orderBy" });
+      }
+      const col = table[column];
+      query = query.orderBy(direction === "asc" ? asc(col) : desc(col));
+    }
+  }
+  const rows = await query;
+  return rows;
+}
+async function findOneImpl(adapter, table, fields, idOrWhere) {
+  let where = null;
+  if (typeof idOrWhere === "string" || typeof idOrWhere === "number") {
+    const pk = findPrimaryKey(fields);
+    if (!pk) {
+      throw new HTTPException(500, { message: "model has no primary key" });
+    }
+    where = { [pk[0]]: idOrWhere };
+  } else {
+    where = idOrWhere;
+  }
+  const whereClause = buildWhereClause(table, fields, where);
+  if (!whereClause) {
+    throw new HTTPException(400, { message: "where clause must not be empty" });
+  }
+  const rows = await adapter.drizzle.select().from(table).where(whereClause).limit(1);
+  return rows.length > 0 ? rows[0] : null;
+}
+async function createImpl(adapter, table, data) {
+  const rows = await adapter.drizzle.insert(table).values(data).returning();
+  return rows[0];
+}
+async function updateImpl(adapter, table, fields, idOrWhere, data) {
+  let where = null;
+  if (typeof idOrWhere === "string" || typeof idOrWhere === "number") {
+    const pk = findPrimaryKey(fields);
+    if (!pk) {
+      throw new HTTPException(500, { message: "model has no primary key" });
+    }
+    where = { [pk[0]]: idOrWhere };
+  } else {
+    where = idOrWhere;
+  }
+  const whereClause = buildWhereClause(table, fields, where);
+  if (!whereClause) {
+    throw new HTTPException(400, { message: "where clause must not be empty" });
+  }
+  const rows = await adapter.drizzle.update(table).set(data).where(whereClause).returning();
+  return rows.length > 0 ? rows[0] : null;
+}
+async function deleteImpl(adapter, table, fields, idOrWhere) {
+  let where = null;
+  if (typeof idOrWhere === "string" || typeof idOrWhere === "number") {
+    const pk = findPrimaryKey(fields);
+    if (!pk) {
+      throw new HTTPException(500, { message: "model has no primary key" });
+    }
+    where = { [pk[0]]: idOrWhere };
+  } else {
+    where = idOrWhere;
+  }
+  const whereClause = buildWhereClause(table, fields, where);
+  if (!whereClause) {
+    throw new HTTPException(400, { message: "where clause must not be empty" });
+  }
+  const result = await adapter.drizzle.delete(table).where(whereClause).returning();
+  return { deleted: result.length };
+}
+function buildBaseObject(fields) {
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    shape[key] = field.zodBase;
+  }
+  return z.object(shape);
+}
+function applySchemaOptions(baseSchema, opts) {
+  if (!opts) {
+    return baseSchema;
+  }
+  let schema = baseSchema;
+  if (opts.pick !== void 0) {
+    const pickArray = Array.from(opts.pick);
+    schema = schema.pick(
+      // biome-ignore lint/suspicious/noExplicitAny: Zod API
+      Object.fromEntries(pickArray.map((k) => [k, true]))
+    );
+  }
+  if (opts.omit !== void 0) {
+    const omitArray = Array.from(opts.omit);
+    schema = schema.omit(
+      // biome-ignore lint/suspicious/noExplicitAny: Zod API
+      Object.fromEntries(omitArray.map((k) => [k, true]))
+    );
+  }
+  if (opts.partial === true) {
+    schema = schema.partial();
+  }
+  return schema;
+}
+function buildTable(tableName, fields) {
+  const columns = {};
+  for (const [key, field] of Object.entries(fields)) {
+    columns[key] = field.drizzleColumn(key);
+  }
+  return sqliteTable(tableName, columns);
+}
+
+// src/model/define.ts
+function defineModel(tableName, fields) {
+  const table = buildTable(tableName, fields);
+  return {
+    fields,
+    tableName,
+    table,
+    schema(opts) {
+      const baseSchema = buildBaseObject(fields);
+      const schema = applySchemaOptions(baseSchema, opts);
+      return schema;
+    },
+    validator(target, opts, hook) {
+      const schema = this.schema(opts);
+      return zValidator(target, schema, hook);
+    },
+    findMany(adapter, options) {
+      return findManyImpl(adapter, table, fields, options);
+    },
+    findOne(adapter, idOrWhere) {
+      return findOneImpl(adapter, table, fields, idOrWhere);
+    },
+    create(adapter, data) {
+      return createImpl(adapter, table, data);
+    },
+    update(adapter, idOrWhere, data) {
+      return updateImpl(adapter, table, fields, idOrWhere, data);
+    },
+    delete(adapter, idOrWhere) {
+      return deleteImpl(adapter, table, fields, idOrWhere);
+    }
+  };
+}
+function nanoka(adapter) {
+  const app = new Hono();
+  Object.defineProperty(app, "db", {
+    get: () => adapter.drizzle,
+    enumerable: true
+  });
+  app.batch = ((queries) => adapter.batch(queries));
+  app.model = function model(name, fields) {
+    const inner = defineModel(name, fields);
+    return {
+      fields: inner.fields,
+      tableName: inner.tableName,
+      table: inner.table,
+      schema: (opts) => inner.schema(opts),
+      validator: (target, opts, hook) => inner.validator(target, opts, hook),
+      findMany: (options) => inner.findMany(adapter, options),
+      findOne: (idOrWhere) => inner.findOne(adapter, idOrWhere),
+      create: (data) => inner.create(adapter, data),
+      update: (idOrWhere, data) => inner.update(adapter, idOrWhere, data),
+      delete: (idOrWhere) => inner.delete(adapter, idOrWhere)
+    };
+  };
+  return app;
+}
+
+export { d1Adapter, defineModel, nanoka };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map