@nanokajs/core 1.6.1 → 1.8.0

package/dist/config.js

@@ -1,4 +1,4 @@
-export { t } from './chunk-GZC7BVP2.js';
+export { t } from './chunk-SHPR4NTZ.js';
 
 // src/config.ts
 function defineConfig(config) {

package/dist/{factories-Cmvx0495.d.ts → factories-CiYoD7dl.d.ts}

@@ -13,7 +13,29 @@ interface FieldModifiers {
     max?: number;
     policy?: FieldPolicy;
 }
-type FieldKind = 'string' | 'uuid' | 'number' | 'integer' | 'boolean' | 'timestamp' | 'json';
+type FieldKind = 'string' | 'uuid' | 'number' | 'integer' | 'boolean' | 'timestamp' | 'json' | 'relation';
+type RelationKind = 'hasMany' | 'belongsTo';
+interface RelationTargetLike {
+    readonly fields: Record<string, {
+        kind: FieldKind;
+        zodBase: unknown;
+        drizzleColumn(name: string): unknown;
+    }>;
+    readonly tableName: string;
+}
+interface RelationDef<Target extends RelationTargetLike = RelationTargetLike, FK extends string = string> {
+    readonly kind: 'relation';
+    readonly relationKind: RelationKind;
+    readonly target: Target | (() => Target);
+    readonly foreignKey: FK;
+    readonly tsType: never;
+    readonly zodBase: z.ZodNever;
+    readonly modifiers: {};
+    drizzleColumn(name: string): never;
+}
+type IsRelationField<F> = F extends {
+    kind: 'relation';
+} ? true : false;
 /**
  * Represents a typed database field with Zod validation and Drizzle column mapping.
  *
@@ -431,6 +453,17 @@ declare class JsonFieldBuilder<T = unknown, TS = T, Mods extends FieldModifiers
         policy: 'readOnly';
     }>;
 }
+declare class RelationFieldBuilder<Target extends RelationTargetLike, FK extends string, Kind extends RelationKind> {
+    readonly kind: "relation";
+    readonly relationKind: Kind;
+    readonly target: Target | (() => Target);
+    readonly foreignKey: FK;
+    readonly tsType: never;
+    readonly modifiers: {};
+    constructor(relationKind: Kind, target: Target | (() => Target), foreignKey: FK);
+    get zodBase(): z.ZodNever;
+    drizzleColumn(name: string): never;
+}
 declare function jsonField<S extends z.ZodTypeAny>(schema: S): JsonFieldBuilder<z.infer<S>, z.infer<S>, {}>;
 declare function jsonField<T = unknown>(): JsonFieldBuilder<T, T, {}>;
 /**
@@ -464,6 +497,12 @@ declare const t: {
      * Drizzle 型が欲しい場合は生成後に手動で書き換えるか `as` を使うこと。
      */
     json: typeof jsonField;
+    hasMany<Target extends RelationTargetLike, FK extends string>(target: Target | (() => Target), options: {
+        foreignKey: FK;
+    }): RelationFieldBuilder<Target, FK, "hasMany">;
+    belongsTo<Target extends RelationTargetLike, FK extends string>(target: Target | (() => Target), options: {
+        foreignKey: FK;
+    }): RelationFieldBuilder<Target, FK, "belongsTo">;
 };
 
-export { type Field as F, type InferFieldType as I, type FieldPolicy as a, type FieldModifiers as b, t };
+export { type Field as F, type InferFieldType as I, type RelationDef as R, type FieldPolicy as a, type FieldModifiers as b, type IsRelationField as c, RelationFieldBuilder as d, type RelationKind as e, type RelationTargetLike as f, t };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { D1Database } from '@cloudflare/workers-types';
 import { A as Adapter } from './types-D2QDVyks.js';
-import { F as Field, I as InferFieldType, a as FieldPolicy } from './factories-Cmvx0495.js';
-export { b as FieldModifiers, t } from './factories-Cmvx0495.js';
+import { F as Field, I as InferFieldType, a as FieldPolicy, R as RelationDef } from './factories-CiYoD7dl.js';
+export { b as FieldModifiers, c as IsRelationField, d as RelationFieldBuilder, e as RelationKind, f as RelationTargetLike, t } from './factories-CiYoD7dl.js';
 import { Hook } from '@hono/zod-validator';
 import { SQL } from 'drizzle-orm';
 import { SQLiteTableWithColumns, AnySQLiteColumn } from 'drizzle-orm/sqlite-core';
@@ -81,6 +81,35 @@ interface OpenAPIDocument {
     readonly paths: Record<string, Record<string, unknown>>;
 }
 
+/**
+ * @internal
+ * Extracts keys of non-relation fields from a Fields record.
+ * Relation fields (kind: 'relation') are excluded from DB column types, RowType, etc.
+ */
+type NonRelationKeys<Fields extends Record<string, Field<any, any, any>>> = {
+    [K in keyof Fields]: Fields[K] extends {
+        kind: 'relation';
+    } ? never : K;
+}[keyof Fields];
+/**
+ * @internal
+ * Extracts keys of relation fields from a Fields record.
+ */
+type RelationKeys<Fields extends Record<string, Field<any, any, any>>> = {
+    [K in keyof Fields]: Fields[K] extends {
+        kind: 'relation';
+    } ? K : never;
+}[keyof Fields];
+type RelationTargetFields<Target> = Target extends () => infer Resolved ? RelationTargetFields<Resolved> : Target extends {
+    fields: infer TargetFields;
+} ? TargetFields : never;
+type RelationResult<F> = F extends RelationDef<infer Target, string> ? RelationTargetFields<Target> extends Record<string, Field<any, any, any>> ? F['relationKind'] extends 'hasMany' ? RowType<RelationTargetFields<Target>>[] : RowType<RelationTargetFields<Target>> | null : never : never;
+type WithOptions<Fields extends Record<string, Field<any, any, any>>> = {
+    readonly [K in RelationKeys<Fields>]?: true;
+};
+type WithResult<Fields extends Record<string, Field<any, any, any>>, With> = RowType<Fields> & {
+    readonly [K in keyof With]: RelationResult<Fields[K & keyof Fields]>;
+};
 /**
  * Options for findMany query.
  * `limit` is required (no default).
@@ -88,11 +117,15 @@ interface OpenAPIDocument {
  * `orderBy` is optional for column ordering.
  * `where` accepts either an equality object or a Drizzle SQL expression.
  */
-interface FindManyOptions<Fields extends Record<string, Field<any, any, any>>> {
+interface FindManyOptions<Fields extends Record<string, Field<any, any, any>>, With extends WithOptions<Fields> | undefined = undefined> {
     readonly limit: number;
     readonly offset?: number;
     readonly orderBy?: OrderBy<Fields>;
     readonly where?: Where<Fields> | SQL;
+    readonly with?: With;
+}
+interface FindOneOptions<Fields extends Record<string, Field<any, any, any>>, With extends WithOptions<Fields> | undefined = undefined> {
+    readonly with?: With;
 }
 /**
  * Options for findAll query.
@@ -107,38 +140,38 @@ interface FindAllOptions<Fields extends Record<string, Field<any, any, any>>> {
 /**
  * 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;
+type OrderBy<Fields extends Record<string, Field<any, any, any>>> = (NonRelationKeys<Fields> & string) | {
+    readonly column: NonRelationKeys<Fields> & string;
     readonly direction?: 'asc' | 'desc';
-} | ReadonlyArray<(keyof Fields & string) | {
-    readonly column: keyof Fields & string;
+} | ReadonlyArray<(NonRelationKeys<Fields> & string) | {
+    readonly column: NonRelationKeys<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]>;
+    readonly [K in NonRelationKeys<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.
+ * Row type: full record type from fields, excluding relation fields.
  */
 type RowType<Fields extends Record<string, Field<any, any, any>>> = {
-    [K in keyof Fields]: InferFieldType<Fields[K]>;
+    [K in NonRelationKeys<Fields>]: InferFieldType<Fields[K]>;
 };
 /**
- * Drizzle table type with columns typed to match the model's Fields.
+ * Drizzle table type with columns typed to match the model's Fields (excluding relation fields).
  * Allows type-safe column access via Model.table.fieldName.
  */
 type ModelTable<Fields extends Record<string, Field<any, any, any>>> = SQLiteTableWithColumns<{
     name: string;
     schema: undefined;
     columns: {
-        [K in keyof Fields]: AnySQLiteColumn;
+        [K in NonRelationKeys<Fields>]: AnySQLiteColumn;
     };
     dialect: 'sqlite';
 }>;
@@ -209,11 +242,12 @@ type IsRequired<F extends Field<any, any, any>> = F extends Field<any, {
  * - all other fields are required
  * - `serverOnly` fields are completely excluded (cannot be passed even internally)
  * - `writeOnly` fields are included as required (they are input fields by design)
+ * - relation fields are completely excluded (no DB column)
  */
 type CreateInput<Fields extends Record<string, Field<any, any, any>>> = {
-    [K in keyof Fields as IsRequired<Fields[K]> extends true ? K extends ServerOnlyKeys<Fields> ? never : K : never]: InferFieldType<Fields[K]>;
+    [K in NonRelationKeys<Fields> as IsRequired<Fields[K]> extends true ? K extends ServerOnlyKeys<Fields> ? never : K : never]: InferFieldType<Fields[K]>;
 } & {
-    [K in keyof Fields as IsRequired<Fields[K]> extends true ? never : K extends ServerOnlyKeys<Fields> ? never : K]?: InferFieldType<Fields[K]>;
+    [K in NonRelationKeys<Fields> as IsRequired<Fields[K]> extends true ? never : K extends ServerOnlyKeys<Fields> ? never : K]?: InferFieldType<Fields[K]>;
 };
 type FieldAccessor<K extends string> = {
     readonly [Key in K]: Key;
@@ -226,11 +260,12 @@ interface SchemaOptions<K extends string = string> {
 /**
  * @internal
  * Extracts a Zod shape from fields for the Apply type.
- * Each field's zodBase becomes a property in the shape.
+ * Only non-relation fields are included (relation fields have zodBase: ZodNever
+ * and are skipped at runtime in buildBaseObject).
  * 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'];
+    [K in NonRelationKeys<Fields>]: Fields[K]['zodBase'];
 };
 /**
  * @internal
@@ -352,7 +387,7 @@ type ValidatorInput<Target extends keyof ValidationTargets, Schema extends z.Zod
  * Uses RowType<Fields> directly for input/output type computation
  * to ensure Zod v3/v4 compatibility (z.input<ZodTypeAny> returns unknown in Zod v4).
  */
-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>, ApplyToRecord<RowType<Fields>, Opts>, ApplyToRecord<RowType<Fields>, Opts>>>;
+type ModelValidatorReturn<Fields extends Record<string, Field<any, any, any>>, Target extends keyof ValidationTargets, Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | undefined> = MiddlewareHandler<any, string, ValidatorInput<Target, Apply<FieldsToZodShape<Fields>, Opts>, ApplyToRecord<RowType<Fields>, Opts>, ApplyToRecord<RowType<Fields>, Opts>>>;
 
 /**
  * Represents a database model with type-safe schema derivation and CRUD operations.
@@ -369,7 +404,7 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      * const CreateSchema = User.schema({ omit: ['passwordHash'] })
      * const UpdateSchema = User.schema({ partial: true, pick: ['name', 'email'] })
      */
-    schema<Opts extends SchemaOptions<keyof Fields & string> | undefined>(opts?: Opts): Apply<FieldsToZodShape<Fields>, Opts>;
+    schema<Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | 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.
@@ -393,7 +428,7 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      */
     validator<Target extends keyof ValidationTargets, E extends Env = Env, P extends string = string>(target: Target, preset: 'create', hook?: Hook<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, E, P, Target>): MiddlewareHandler<E, P, ValidatorInput<Target, z.ZodObject<z.ZodRawShape>, Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>>>;
     validator<Target extends keyof ValidationTargets, E extends Env = Env, P extends string = string>(target: Target, preset: 'update', hook?: Hook<Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>, E, P, Target>): MiddlewareHandler<E, P, ValidatorInput<Target, z.ZodObject<z.ZodRawShape>, Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>, Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>>>;
-    validator<Target extends keyof ValidationTargets, Opts extends SchemaOptions<keyof Fields & string> | 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>;
+    validator<Target extends keyof ValidationTargets, Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | 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>;
     /**
      * Returns a Zod schema for API input, with policy-based field exclusions applied.
      * - 'create': serverOnly and readOnly fields are excluded
@@ -401,13 +436,13 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      *
      * The return type precisely reflects policy-derived omissions using PolicyOmitKeys.
      */
-    inputSchema<Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined>(usage: 'create', opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, Opts>>;
-    inputSchema<Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined>(usage: 'update', opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>, Opts extends undefined ? {
+    inputSchema<Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | undefined = undefined>(usage: 'create', opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, Opts>>;
+    inputSchema<Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | undefined = undefined>(usage: 'update', opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>, Opts extends undefined ? {
         partial: true;
     } : Opts & {
         partial: true;
     }>>;
-    inputSchema(usage: 'create' | 'update', opts?: SchemaOptions<keyof Fields & string>): z.ZodObject<z.ZodRawShape>;
+    inputSchema(usage: 'create' | 'update', opts?: SchemaOptions<NonRelationKeys<Fields> & string>): z.ZodObject<z.ZodRawShape>;
     /**
      * Returns a Zod schema for API output, with policy-based field exclusions applied.
      * - serverOnly and writeOnly fields are excluded
@@ -415,7 +450,7 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      *
      * The return type precisely reflects policy-derived omissions using PolicyOmitKeys.
      */
-    outputSchema<Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined>(opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'output'> & string>, Opts>>;
+    outputSchema<Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | undefined = undefined>(opts?: Opts): z.ZodObject<ApplyShape<Omit<FieldsToZodShape<Fields>, PolicyOmitKeys<Fields, 'output'> & string>, Opts>>;
     /**
      * Parses a DB row through outputSchema and returns the safe response object.
      * Equivalent to `User.outputSchema().parse(row)`.
@@ -443,6 +478,9 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      * const page2 = await User.findMany(adapter, { limit: 20, offset: 20 })
      * const sorted = await User.findMany(adapter, { limit: 10, orderBy: 'name' })
      */
+    findMany<With extends WithOptions<Fields>>(adapter: Adapter, options: FindManyOptions<Fields, With> & {
+        readonly with: With;
+    }): Promise<WithResult<Fields, With>[]>;
     findMany(adapter: Adapter, options: FindManyOptions<Fields>): Promise<RowType<Fields>[]>;
     /**
      * Fetches all rows without a LIMIT clause.
@@ -461,6 +499,9 @@ interface Model<Fields extends Record<string, Field<any, any, any>>> {
      * const user = await User.findOne(adapter, id)
      * const byEmail = await User.findOne(adapter, { email: 'john@example.com' })
      */
+    findOne<With extends WithOptions<Fields>>(adapter: Adapter, idOrWhere: IdOrWhere<Fields>, options: FindOneOptions<Fields, With> & {
+        readonly with: With;
+    }): Promise<WithResult<Fields, With> | null>;
     findOne(adapter: Adapter, idOrWhere: IdOrWhere<Fields>): Promise<RowType<Fields> | null>;
     /**
      * Creates a new row and returns the created record.
@@ -529,7 +570,7 @@ interface NanokaModel<Fields extends Record<string, Field<any, any, any>>> {
      * 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>;
+    schema<Opts extends SchemaOptions<NonRelationKeys<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.
@@ -537,15 +578,15 @@ interface NanokaModel<Fields extends Record<string, Field<any, any, any>>> {
      */
     validator<Target extends keyof hono.ValidationTargets, E extends Env$1 = Env$1, P extends string = string>(target: Target, preset: 'create', hook?: Hook<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, E, P, Target>): MiddlewareHandler<E, P, ValidatorInput<Target, z.ZodObject<z.ZodRawShape>, Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>, Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-create'> & string>>>;
     validator<Target extends keyof hono.ValidationTargets, E extends Env$1 = Env$1, P extends string = string>(target: Target, preset: 'update', hook?: Hook<Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>, E, P, Target>): MiddlewareHandler<E, P, ValidatorInput<Target, z.ZodObject<z.ZodRawShape>, Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>, Partial<Omit<RowType<Fields>, PolicyOmitKeys<Fields, 'input-update'> & string>>>>;
-    validator<Target extends keyof hono.ValidationTargets, Opts extends SchemaOptions<keyof Fields & string> | undefined = undefined, E extends Env$1 = Env$1, P extends string = string>(target: Target, opts?: Opts, hook?: Hook<z.output<Apply<FieldsToZodShape<Fields>, Opts>>, E, P, Target>): ModelValidatorReturn<Fields, Target, Opts>;
+    validator<Target extends keyof hono.ValidationTargets, Opts extends SchemaOptions<NonRelationKeys<Fields> & string> | undefined = undefined, E extends Env$1 = Env$1, P extends string = string>(target: Target, opts?: Opts, hook?: Hook<z.output<Apply<FieldsToZodShape<Fields>, Opts>>, E, P, Target>): ModelValidatorReturn<Fields, Target, Opts>;
     /**
      * Returns a Zod schema for API input, with policy-based field exclusions applied.
      */
-    inputSchema(usage: 'create' | 'update', opts?: SchemaOptions<keyof Fields & string>): z.ZodObject<z.ZodRawShape>;
+    inputSchema(usage: 'create' | 'update', opts?: SchemaOptions<NonRelationKeys<Fields> & string>): z.ZodObject<z.ZodRawShape>;
     /**
      * Returns a Zod schema for API output, with policy-based field exclusions applied.
      */
-    outputSchema(opts?: SchemaOptions<keyof Fields & string>): z.ZodObject<z.ZodRawShape>;
+    outputSchema(opts?: SchemaOptions<NonRelationKeys<Fields> & string>): z.ZodObject<z.ZodRawShape>;
     /**
      * Parses a DB row through outputSchema and returns the safe response object.
      */
@@ -557,6 +598,9 @@ interface NanokaModel<Fields extends Record<string, Field<any, any, any>>> {
      * Fetches multiple rows with pagination and optional ordering.
      * `limit` is required (no default) to prevent accidental unbounded queries.
      */
+    findMany<With extends WithOptions<Fields>>(options: FindManyOptions<Fields, With> & {
+        readonly with: With;
+    }): Promise<WithResult<Fields, With>[]>;
     findMany(options: FindManyOptions<Fields>): Promise<RowType<Fields>[]>;
     /**
      * Fetches all rows without a LIMIT clause.
@@ -567,6 +611,9 @@ interface NanokaModel<Fields extends Record<string, Field<any, any, any>>> {
      * Fetches a single row by primary key or where clause.
      * Returns null if not found.
      */
+    findOne<With extends WithOptions<Fields>>(idOrWhere: IdOrWhere<Fields>, options: FindOneOptions<Fields, With> & {
+        readonly with: With;
+    }): Promise<WithResult<Fields, With> | null>;
     findOne(idOrWhere: IdOrWhere<Fields>): Promise<RowType<Fields> | null>;
     /**
      * Creates a new row and returns the created record.
@@ -655,4 +702,4 @@ interface Nanoka<E extends Env$1 = BlankEnv> extends Hono<E> {
  */
 declare function nanoka<E extends Env$1 = BlankEnv>(adapter: Adapter): Nanoka<E>;
 
-export { Adapter, type CreateInput, Field, FieldPolicy, type FindAllOptions, type FindManyOptions, type HttpMethod, type IdOrWhere, InferFieldType, type Model, type Nanoka, type NanokaModel, type OpenAPIDocument, type OpenAPIModelComponent, type OpenAPIParamSpec, type OpenAPIRequestBodySpec, type OpenAPIResponseSpec, type OpenAPIRouteMetadata, type OpenAPISchemaObject, type OpenAPISpecOptions, type OpenAPIUsage, type OrderBy, type RouteOpenAPIMetadata, type RouteOpenAPIOption, type RowType, type SchemaOptions, type Where, d1Adapter, defineModel, nanoka, swaggerUI };
+export { Adapter, type CreateInput, Field, FieldPolicy, type FindAllOptions, type FindManyOptions, type FindOneOptions, type HttpMethod, type IdOrWhere, InferFieldType, type Model, type Nanoka, type NanokaModel, type OpenAPIDocument, type OpenAPIModelComponent, type OpenAPIParamSpec, type OpenAPIRequestBodySpec, type OpenAPIResponseSpec, type OpenAPIRouteMetadata, type OpenAPISchemaObject, type OpenAPISpecOptions, type OpenAPIUsage, type OrderBy, RelationDef, type RelationKeys, type RouteOpenAPIMetadata, type RouteOpenAPIOption, type RowType, type SchemaOptions, type Where, type WithOptions, type WithResult, d1Adapter, defineModel, nanoka, swaggerUI };

package/dist/index.js

@@ -1,8 +1,8 @@
-export { t } from './chunk-GZC7BVP2.js';
+export { t } from './chunk-SHPR4NTZ.js';
 import { drizzle } from 'drizzle-orm/d1';
 import { zValidator } from '@hono/zod-validator';
 import { z } from 'zod';
-import { SQL, asc, desc, eq, and } from 'drizzle-orm';
+import { SQL, asc, desc, eq, and, inArray } from 'drizzle-orm';
 import { HTTPException } from 'hono/http-exception';
 import { sqliteTable } from 'drizzle-orm/sqlite-core';
 import { Hono } from 'hono';
@@ -23,7 +23,10 @@ function resolveSchemaOptionKeys(opt, accessor) {
 }
 function buildFieldAccessor(fields) {
   const acc = {};
-  for (const k of Object.keys(fields)) acc[k] = k;
+  for (const [k, field] of Object.entries(fields)) {
+    if (field.kind === "relation") continue;
+    acc[k] = k;
+  }
   return Object.freeze(acc);
 }
 
@@ -37,6 +40,13 @@ function computeForcedOmit(fields) {
   }
   return omit;
 }
+function computeRelationOmit(fields) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.kind === "relation") keys.add(key);
+  }
+  return keys;
+}
 function computeOptionalOmit(fields, target) {
   const omit = [];
   for (const [key, field] of Object.entries(fields)) {
@@ -51,7 +61,9 @@ function computeOptionalOmit(fields, target) {
   return omit;
 }
 function derivePolicyOptions(fields, usage, userOpts, accessor) {
-  const forced = computeForcedOmit(fields);
+  const forcedBase = computeForcedOmit(fields);
+  const relationOmit = computeRelationOmit(fields);
+  const forced = [.../* @__PURE__ */ new Set([...forcedBase, ...relationOmit])];
   const optional = computeOptionalOmit(fields, usage);
   const acc = accessor ?? {};
   const resolvedPick = resolveSchemaOptionKeys(userOpts?.pick, acc);
@@ -79,6 +91,7 @@ function derivePolicyOptions(fields, usage, userOpts, accessor) {
 function buildBaseObject(fields) {
   const shape = {};
   for (const [key, field] of Object.entries(fields)) {
+    if (field.kind === "relation") continue;
     shape[key] = field.zodBase;
   }
   return z.object(shape);
@@ -129,6 +142,7 @@ function toOpenAPISchema(fields, usage, opts) {
   for (const [key, zodSchema] of Object.entries(shape)) {
     const field = fields[key];
     if (field === void 0) continue;
+    if (field.kind === "relation") continue;
     properties[key] = fieldToOpenAPISchema(field, opts?.strict);
     if (field.modifiers.policy === "writeOnly" && (usage === "create" || usage === "update")) {
       properties[key].writeOnly = true;
@@ -316,6 +330,16 @@ function getZodCheckDef(check) {
   }
   return check;
 }
+function buildTable(tableName, fields) {
+  const columns = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.kind === "relation") continue;
+    columns[key] = field.drizzleColumn(key);
+  }
+  return sqliteTable(tableName, columns);
+}
+
+// src/model/crud.ts
 function guardLimit(limit) {
   if (!Number.isInteger(limit)) {
     throw new HTTPException(400, { message: "limit must be an integer" });
@@ -380,6 +404,143 @@ function buildWhereClause(table, fields, where) {
   }
   return and(...conditions);
 }
+function resolveRelationTarget(field) {
+  return typeof field.target === "function" ? field.target() : field.target;
+}
+function getTargetTable(target) {
+  if (Object.hasOwn(target, "table")) {
+    return target.table;
+  }
+  return buildTable(target.tableName, target.fields);
+}
+function validateWithOptions(fields, withOptions) {
+  if (withOptions === null || typeof withOptions !== "object" || Array.isArray(withOptions)) {
+    throw new HTTPException(400, { message: "invalid with option" });
+  }
+  for (const [key, value] of Object.entries(withOptions)) {
+    if (value !== true) {
+      throw new HTTPException(400, { message: "nested with is not supported" });
+    }
+    if (!Object.hasOwn(fields, key) || fields[key]?.kind !== "relation") {
+      throw new HTTPException(400, { message: "invalid relation in with option" });
+    }
+  }
+}
+var relationCycleCache = /* @__PURE__ */ new WeakMap();
+function assertNoRelationCycle(fields, rootName = "root") {
+  const cached = relationCycleCache.get(fields);
+  if (cached !== void 0) {
+    if (cached !== null) throw cached;
+    return;
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (currentFields, path) => {
+    if (visiting.has(currentFields)) {
+      return new HTTPException(500, { message: "relation cycle detected" });
+    }
+    if (visited.has(currentFields)) {
+      return null;
+    }
+    visiting.add(currentFields);
+    for (const field of Object.values(currentFields)) {
+      if (field.kind !== "relation") continue;
+      const target = resolveRelationTarget(field);
+      const targetFields = target.fields;
+      const error2 = visit(targetFields, [...path, target.tableName]);
+      if (error2 !== null) {
+        return error2;
+      }
+    }
+    visiting.delete(currentFields);
+    visited.add(currentFields);
+    return null;
+  };
+  const error = visit(fields, [rootName]);
+  relationCycleCache.set(fields, error);
+  if (error !== null) {
+    throw error;
+  }
+}
+async function loadRelations(adapter, _parentTable, parentFields, parentRows, withOptions) {
+  if (parentRows.length === 0) {
+    return [];
+  }
+  const rows = parentRows.map((row) => ({ ...row }));
+  for (const relationKey of Object.keys(withOptions)) {
+    const field = parentFields[relationKey];
+    if (field?.kind !== "relation") {
+      throw new HTTPException(400, { message: "invalid relation in with option" });
+    }
+    const relation = field;
+    const target = resolveRelationTarget(relation);
+    const targetFields = target.fields;
+    const targetTable = getTargetTable(target);
+    if (relation.relationKind === "hasMany") {
+      const parentPk = findPrimaryKey(parentFields);
+      if (!parentPk) {
+        throw new HTTPException(500, { message: "model has no primary key" });
+      }
+      const parentPkKey = parentPk[0];
+      const foreignKey = relation.foreignKey;
+      if (!Object.hasOwn(targetFields, foreignKey) || !Object.hasOwn(targetTable, foreignKey)) {
+        throw new HTTPException(500, { message: "invalid relation foreign key" });
+      }
+      const parentIds = Array.from(
+        new Set(parentRows.map((row) => row[parentPkKey]))
+      );
+      const targetRows = parentIds.length === 0 ? [] : await adapter.drizzle.select().from(targetTable).where(
+        inArray(
+          targetTable[foreignKey],
+          parentIds
+        )
+      );
+      const grouped = /* @__PURE__ */ new Map();
+      for (const targetRow of targetRows) {
+        const value = targetRow[foreignKey];
+        const group = grouped.get(value);
+        if (group === void 0) {
+          grouped.set(value, [targetRow]);
+        } else {
+          group.push(targetRow);
+        }
+      }
+      for (const row of rows) {
+        row[relationKey] = grouped.get(row[parentPkKey]) ?? [];
+      }
+    } else {
+      const foreignKey = relation.foreignKey;
+      if (!Object.hasOwn(parentFields, foreignKey) || !Object.hasOwn(_parentTable, foreignKey)) {
+        throw new HTTPException(500, { message: "invalid relation foreign key" });
+      }
+      const targetPk = findPrimaryKey(targetFields);
+      if (!targetPk) {
+        throw new HTTPException(500, { message: "model has no primary key" });
+      }
+      const targetPkKey = targetPk[0];
+      if (!Object.hasOwn(targetTable, targetPkKey)) {
+        throw new HTTPException(500, { message: "invalid relation primary key" });
+      }
+      const parentFkValues = Array.from(
+        new Set(parentRows.map((row) => row[foreignKey]))
+      );
+      const targetRows = parentFkValues.length === 0 ? [] : await adapter.drizzle.select().from(targetTable).where(
+        inArray(
+          targetTable[targetPkKey],
+          parentFkValues
+        )
+      );
+      const byPk = /* @__PURE__ */ new Map();
+      for (const targetRow of targetRows) {
+        byPk.set(targetRow[targetPkKey], targetRow);
+      }
+      for (const row of rows) {
+        row[relationKey] = byPk.get(row[foreignKey]) ?? null;
+      }
+    }
+  }
+  return rows;
+}
 async function findManyImpl(adapter, table, fields, options) {
   const limit = guardLimit(options.limit);
   const offset = options.offset !== void 0 ? guardOffset(options.offset) : 0;
@@ -421,6 +582,11 @@ async function findManyImpl(adapter, table, fields, options) {
     }
   }
   const rows = await query;
+  if (options.with !== void 0) {
+    validateWithOptions(fields, options.with);
+    assertNoRelationCycle(fields);
+    return loadRelations(adapter, table, fields, rows, options.with);
+  }
   return rows;
 }
 async function findAllImpl(adapter, table, fields, options) {
@@ -465,7 +631,7 @@ async function findAllImpl(adapter, table, fields, options) {
   const rows = await query;
   return rows;
 }
-async function findOneImpl(adapter, table, fields, idOrWhere) {
+async function findOneImpl(adapter, table, fields, idOrWhere, options) {
   let where = null;
   if (typeof idOrWhere === "string" || typeof idOrWhere === "number") {
     const pk = findPrimaryKey(fields);
@@ -480,8 +646,19 @@ async function findOneImpl(adapter, table, fields, idOrWhere) {
   if (!whereClause) {
     throw new HTTPException(400, { message: "where clause must not be empty" });
   }
+  if (options?.with !== void 0) {
+    validateWithOptions(fields, options.with);
+    assertNoRelationCycle(fields);
+  }
   const rows = await adapter.drizzle.select().from(table).where(whereClause).limit(1);
-  return rows.length > 0 ? rows[0] : null;
+  if (rows.length === 0) {
+    return null;
+  }
+  if (options?.with !== void 0) {
+    const withRows = await loadRelations(adapter, table, fields, [rows[0]], options.with);
+    return withRows[0] ?? null;
+  }
+  return rows[0];
 }
 async function createImpl(adapter, table, data) {
   const rows = await adapter.drizzle.insert(table).values(data).returning();
@@ -523,13 +700,6 @@ async function deleteImpl(adapter, table, fields, idOrWhere) {
   const result = await adapter.drizzle.delete(table).where(whereClause).returning();
   return { deleted: result.length };
 }
-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) {
@@ -581,15 +751,11 @@ function defineModel(tableName, fields) {
     toOpenAPISchema(usage) {
       return toOpenAPISchema(fields, usage);
     },
-    findMany(adapter, options) {
-      return findManyImpl(adapter, table, fields, options);
-    },
+    findMany: ((adapter, options) => findManyImpl(adapter, table, fields, options)),
     findAll(adapter, options) {
       return findAllImpl(adapter, table, fields, options);
     },
-    findOne(adapter, idOrWhere) {
-      return findOneImpl(adapter, table, fields, idOrWhere);
-    },
+    findOne: ((adapter, idOrWhere, options) => findOneImpl(adapter, table, fields, idOrWhere, options)),
     create(adapter, data) {
       return createImpl(adapter, table, data);
     },
@@ -716,9 +882,9 @@ function nanoka(adapter) {
       toResponseMany: (rows) => inner.toResponseMany(rows),
       toOpenAPIComponent: () => inner.toOpenAPIComponent(),
       toOpenAPISchema: (usage) => inner.toOpenAPISchema(usage),
-      findMany: (options) => inner.findMany(adapter, options),
+      findMany: ((options) => inner.findMany(adapter, options)),
       findAll: (options) => inner.findAll(adapter, options),
-      findOne: (idOrWhere) => inner.findOne(adapter, idOrWhere),
+      findOne: ((idOrWhere, options) => inner.findOne(adapter, idOrWhere, options)),
       create: (data) => inner.create(adapter, data),
       update: (idOrWhere, data) => inner.update(adapter, idOrWhere, data),
       delete: (idOrWhere) => inner.delete(adapter, idOrWhere)