@kizaki/schema

@kizaki/schema is generated from your .inspire schema. It exports one EntityTable object per entity, each carrying typed FieldRef properties for query builders and TypeScript type inference.

What Is Generated

For each entity, the compiler produces an object with a _name property and a FieldRef for every field.

Inspire schema:

  entity Project {
    name: string
    ownerId: __User.id
  }

Generated object:

  Project._name   → "Project"
  Project.id      → FieldRef<string>    (auto-generated primary key)
  Project.name    → FieldRef<string>
  Project.ownerId → FieldRef<string>

Generated files live at .kizaki/build/schema/. Never edit them by hand.

Using Entity Objects

Entity objects are the first argument to every query builder, on both server and browser.

import { Project } from "@kizaki/schema";
import { query, select, eq } from "@kizaki/sdk";

const projects = await query(
  select(Project)
    .fields(Project.id, Project.name)
    .where(eq(Project.ownerId, userId))
);

The same Project object works identically in browser query builders:

import { Project } from "@kizaki/schema";
import { select, eq } from "@kizaki/sdk/browser";

const projectsQuery = select(Project)
  .fields(Project.id, Project.name)
  .where(eq(Project.ownerId, userId));

Row Type Inference

InferRow extracts the TypeScript type for a full entity row.

import { InferRow } from "@kizaki/sdk";
import { Project } from "@kizaki/schema";

type ProjectRow = InferRow<typeof Project>;
// { id: string; name: string; ownerId: string; createdAt: Date; updatedAt: Date }

Use it for function parameters, component props, or state variables.

function ProjectCard({ project }: { project: InferRow<typeof Project> }) {
  return <h2>{project.name}</h2>;
}

FieldRef vs. String Names

Query builders accept both FieldRef objects and plain strings. Both produce the same SQL, but FieldRef provides compile-time type checking.

// Type-safe — the compiler catches typos and type mismatches
select(Project).where(eq(Project.ownerId, userId))

// Also works, but no type checking
select("Project").where(eq("ownerId", userId))

A misspelled field like Project.ownerID is a TypeScript error at compile time. With strings, the error surfaces only at runtime.

Prefer FieldRef for application code. String names exist for dynamic queries where the entity or field is determined at runtime.

Shared Across Surfaces

@kizaki/schema is imported by every TypeScript layer:

• Server code — alongside @kizaki/sdk for query builders
• Browser queries — alongside @kizaki/sdk/browser for live subscriptions
• React components — to build queries passed to useQuery()
• Generated client stubs — for parameter and return types

It is the single generated source of truth. Every layer references it rather than maintaining parallel type definitions.

Related guide: Query Data In The Browser