@netscript/contracts

Contract vocabulary shared across NetScript package and plugin boundaries: the oRPC base contract, common error data, pagination schemas, result types, and schema helper factories. Because a contract's input schema is enforced at the transport boundary, a service handler never hand-parses or validates req.json() — a request that doesn't match the schema is rejected before your code runs, and the same contract types the client that calls it. This page is written against the package's public surface reported by deno doc. For the full index of packages and plugins return to the reference overview.

The root entrypoint (@netscript/contracts) carries the core contract primitives. Three sub-path exports add higher-level builders:

• @netscript/contracts/crud — CRUD contract generators.
• @netscript/contracts/query — query, filter, and pagination helpers.
• @netscript/contracts/transform — typed transformer factories.

Base contract

Schema helper factories

Errors

Pagination schemas

Constants

Diagnostics

Result and error types

Schema and pagination types

Schema option types

Sub-path exports

The following entrypoints are published alongside the root export. Their symbols are generated from their own deno doc surface.

@netscript/contracts/crud

@netscript/contracts/query

Pagination Executors

The @netscript/contracts/query subpath exports three typed executors to apply validated pagination parameters to a Prisma query:

• paginatedQuery: Page-based pagination (page, limit) returning total count and pages.
• offsetPaginatedQuery: Offset-based pagination (offset, limit) returning total count and a boolean indicating if more items exist.
• cursorPaginatedQuery: Cursor-based pagination (cursor, limit, direction) returning the next cursor.

Page Pagination (page + limit)

Shows schema, contract, validated input, typed Prisma execution, and response metadata.

import { z } from 'zod';
import { baseContract, type BaseContractRoute } from '@netscript/contracts';
import {
  paginatedQuery,
  PaginationInputSchema,
  createPaginatedOutput,
} from '@netscript/contracts/query';

const UserSchema = z.object({ id: z.number(), name: z.string() });

export const listUsersContract = baseContract
  .route({ method: 'GET', path: '/users' })
  .input(PaginationInputSchema)
  .output(createPaginatedOutput(UserSchema));

export async function handleListUsers(input: z.infer<typeof PaginationInputSchema>) {
  const result = await paginatedQuery(db.user, input);
  return result;
}

Offset Pagination (offset + limit)

Useful for infinite scrolls or simple pagination that doesn't need total pages.

import { z } from 'zod';
import { baseContract } from '@netscript/contracts';
import {
  offsetPaginatedQuery,
  OffsetPaginationInputSchema,
} from '@netscript/contracts/query';

const UserSchema = z.object({ id: z.number(), name: z.string() });

export const listUsersOffsetContract = baseContract
  .route({ method: 'GET', path: '/users/offset' })
  .input(OffsetPaginationInputSchema)
  .output(z.object({
    data: z.array(UserSchema),
    total: z.number(),
    hasMore: z.boolean(),
  }));

export async function handleListUsersOffset(input: z.infer<typeof OffsetPaginationInputSchema>) {
  const result = await offsetPaginatedQuery(db.user, input);
  return result;
}

Cursor Pagination

Ideal for large datasets and active feeds.

import { z } from 'zod';
import { baseContract } from '@netscript/contracts';
import {
  cursorPaginatedQuery,
  CursorPaginationInputSchema,
} from '@netscript/contracts/query';

const UserSchema = z.object({ id: z.number(), name: z.string() });

export const listUsersCursorContract = baseContract
  .route({ method: 'GET', path: '/users/cursor' })
  .input(CursorPaginationInputSchema)
  .output(z.object({
    data: z.array(UserSchema),
    nextCursor: z.string().nullable(),
    hasMore: z.boolean(),
  }));

export async function handleListUsersCursor(input: z.infer<typeof CursorPaginationInputSchema>) {
  const { data, nextCursor, hasMore } = await cursorPaginatedQuery<{ id: number; name: string }>(db.user, {
    cursor: input.cursor,
    limit: input.limit,
    direction: input.direction,
    cursorField: 'id',
  });
  return { data, nextCursor, hasMore };
}

@netscript/contracts/transform

Back to the reference overview.