@core / contracts

1.0.0 ▾

1.0.0

verifiedMIT

GitHub

Shared types for GenPM modules: content, sitemap, search, admin resources, payments and tracked events

Code10 filesContext~532 tokensscan passed

~532 tokens→ src/lib/contracts/AGENTS.md→ .cursor/rules/genpm-core-contracts.mdc

This is exactly what your AI reads when it works in src/lib/contracts. Nothing else is added to its context.

@core/contracts — rules for AI agents

Purpose

Types and small zod schemas shared by GenPM catalog modules, so a module can consume "anything that provides content / sitemap URLs / search documents / admin resources / payments" without importing the concrete module. No logic, no tables, no runtime dependency besides zod.

Map

index.ts — public API. Import from here only.
content.ts — ContentSource, ContentEntry (implemented by @core/content and CMS adapters).
sitemap.ts — SitemapSource (consumed by @core/seo).
search.ts — SearchSource, SearchDocument (consumed by @core/search).
admin.ts — AdminResource, AdminField (consumed by @core/admin).
payment.ts — PaymentProvider (implemented by @core/checkout, used by @core/orders).
events.ts — CommerceEvent, LeadEvent and their zod schemas (consumed by @core/pixels).
money.ts — Money (integer minor units + ISO 4217 code).

Integration

Usually installed as a dependency of another module; nothing to wire.
To expose your own data to the admin, sitemap or search, implement the type and register it in the project file the consuming module documents (src/genpm/admin.ts, src/genpm/seo.ts, src/genpm/search.ts):
```
import { defineSitemapSource } from './lib/contracts/index.ts';
export const projects = defineSitemapSource({ name: 'projects', async *urls() { yield { loc: '/projects' }; } });
```
Validate untrusted tracking payloads with TrackedEventSchema.parse(body) before forwarding them.

Conventions

Money is always { amount: integer minor units, currency: 'EUR' }; never floats.
Sources are async iterables: stream rows in pages, don't load whole tables into memory.
AdminResource.input validates create/update input; permissions are <resource>:<action> (posts:update).

Don't

Don't add implementations or helpers with behaviour here; put them in the module that owns the concept.
Don't change an existing type incompatibly: every catalog module depends on it (major version of the whole train).
Don't import other modules from this folder.

# @core/contracts — rules for AI agents

## Purpose
Types and small zod schemas shared by GenPM catalog modules, so a module can consume "anything that provides content /
sitemap URLs / search documents / admin resources / payments" without importing the concrete module. No logic, no
tables, no runtime dependency besides `zod`.

## Map
- `index.ts` — public API. Import from here only.
- `content.ts` — `ContentSource`, `ContentEntry` (implemented by @core/content and CMS adapters).
- `sitemap.ts` — `SitemapSource` (consumed by @core/seo).
- `search.ts` — `SearchSource`, `SearchDocument` (consumed by @core/search).
- `admin.ts` — `AdminResource`, `AdminField` (consumed by @core/admin).
- `payment.ts` — `PaymentProvider` (implemented by @core/checkout, used by @core/orders).
- `events.ts` — `CommerceEvent`, `LeadEvent` and their zod schemas (consumed by @core/pixels).
- `money.ts` — `Money` (integer minor units + ISO 4217 code).

## Integration
1. Usually installed as a dependency of another module; nothing to wire.
2. To expose your own data to the admin, sitemap or search, implement the type and register it in the project file
   the consuming module documents (`src/genpm/admin.ts`, `src/genpm/seo.ts`, `src/genpm/search.ts`):
   ```ts
   import { defineSitemapSource } from './lib/contracts/index.ts';
   export const projects = defineSitemapSource({ name: 'projects', async *urls() { yield { loc: '/projects' }; } });
   ```
3. Validate untrusted tracking payloads with `TrackedEventSchema.parse(body)` before forwarding them.

## Conventions
- Money is always `{ amount: integer minor units, currency: 'EUR' }`; never floats.
- Sources are async iterables: stream rows in pages, don't load whole tables into memory.
- `AdminResource.input` validates create/update input; permissions are `<resource>:<action>` (`posts:update`).

## Don't
- Don't add implementations or helpers with behaviour here; put them in the module that owns the concept.
- Don't change an existing type incompatibly: every catalog module depends on it (major version of the whole train).
- Don't import other modules from this folder.

The exact tree that will be injected, after .genpmignore. Pinned to

src/lib/contracts/events.tsread-only · 7266529

// Eventos de negocio que se miden (píxeles, tests A/B). Mismo `eventId` en navegador y servidor = deduplicación.
import { z } from 'zod';
import { MoneySchema } from './money.ts';

const Item = z.strictObject({
  id: z.string().min(1).max(128),
  name: z.string().min(1).max(256),
  price: MoneySchema,
  quantity: z.number().int().positive(),
  variant: z.string().max(128).optional(),
  category: z.string().max(128).optional(),
});

const base = { eventId: z.string().min(8).max(64) };

export const CommerceEventSchema = z.discriminatedUnion('type', [
  z.strictObject({ ...base, type: z.literal('view_item'), items: z.array(Item).min(1), value: MoneySchema }),
  z.strictObject({ ...base, type: z.literal('add_to_cart'), items: z.array(Item).min(1), value: MoneySchema }),
  z.strictObject({ ...base, type: z.literal('begin_checkout'), items: z.array(Item).min(1), value: MoneySchema }),
  z.strictObject({
    ...base,
    type: z.literal('purchase'),
    orderId: z.string().min(1).max(128),
    items: z.array(Item).min(1),
    value: MoneySchema,
  }),
]);

export const LeadEventSchema = z.strictObject({
  ...base,
  type: z.literal('lead'),
  formKey: z.string().max(64).optional(),
  value: MoneySchema.optional(),
});

export const TrackedEventSchema = z.union([CommerceEventSchema, LeadEventSchema]);

export type CommerceItem = z.infer<typeof Item>;
export type CommerceEvent = z.infer<typeof CommerceEventSchema>;
export type LeadEvent = z.infer<typeof LeadEventSchema>;
export type TrackedEvent = z.infer<typeof TrackedEventSchema>;