@tailor-platform/sdk 2.1.0 → 2.3.0

package/docs/plugin/custom.md

@@ -18,7 +18,7 @@ const myPlugin: Plugin = {
 export default myPlugin; // Required: must be default export
 ```
 
-This is required so that other plugins and generation-time hooks can use plugin-generated TailorDB types via `getGeneratedType()`.
+This is required so that other plugins and generation-time hooks can use plugin-generated TailorDB tables via `getGeneratedType()`.
 
 ## Plugin Interface
 
@@ -56,38 +56,38 @@ interface Plugin<TypeConfig = unknown, PluginConfig = unknown> {
 | `id`                 | Yes                              | Unique plugin identifier (e.g., `"@my-company/soft-delete"`)                                     |
 | `description`        | Yes                              | Human-readable description                                                                       |
 | `importPath`         | When using definition-time hooks | Path resolvable from `tailor.config.ts` directory. Used for import statements in generated code. |
-| `typeConfigRequired` | No                               | Whether per-type config is required when attaching via `.plugin()`. Default: optional.           |
+| `typeConfigRequired` | No                               | Whether per-table config is required when attaching via `.plugin()`. Default: optional.          |
 | `pluginConfig`       | No                               | Plugin-level config passed via `definePlugins()`. Set via factory function.                      |
 
 ## Hook Reference
 
 ### onTypeLoaded
 
-**Trigger**: Called once for each TailorDB type that has `.plugin({ pluginId: config })` attached.
+**Trigger**: Called once for each TailorDB table that has `.plugin({ pluginId: config })` attached.
 
 **Context** (`PluginProcessContext`):
 
 | Field          | Type              | Description                                |
 | -------------- | ----------------- | ------------------------------------------ |
-| `type`         | `TailorAnyDBType` | The TailorDB type being processed          |
-| `typeConfig`   | `TypeConfig`      | Per-type config from `.plugin()`           |
+| `type`         | `TailorAnyDBType` | The TailorDB table being processed         |
+| `typeConfig`   | `TypeConfig`      | Per-table config from `.plugin()`          |
 | `pluginConfig` | `PluginConfig`    | Plugin-level config from `definePlugins()` |
-| `namespace`    | `string`          | Namespace of the TailorDB type             |
+| `namespace`    | `string`          | Namespace of the TailorDB table            |
 
 **Returns** (`TypePluginOutput`):
 
-| Field       | Type                                            | Description                                           |
-| ----------- | ----------------------------------------------- | ----------------------------------------------------- |
-| `types`     | `Record<string, TailorAnyDBType>`               | Additional TailorDB types to generate (keyed by kind) |
-| `resolvers` | `PluginGeneratedResolver[]`                     | Additional resolvers to generate                      |
-| `executors` | `PluginGeneratedExecutor[]`                     | Additional executors to generate                      |
-| `extends`   | `{ fields?: Record<string, TailorAnyDBField> }` | Fields to add to the source type                      |
+| Field       | Type                                            | Description                                            |
+| ----------- | ----------------------------------------------- | ------------------------------------------------------ |
+| `types`     | `Record<string, TailorAnyDBType>`               | Additional TailorDB tables to generate (keyed by kind) |
+| `resolvers` | `PluginGeneratedResolver[]`                     | Additional resolvers to generate                       |
+| `executors` | `PluginGeneratedExecutor[]`                     | Additional executors to generate                       |
+| `extends`   | `{ fields?: Record<string, TailorAnyDBField> }` | Fields to add to the source table                      |
 
 **Use cases**:
 
-- Generate derived types (e.g., archive tables, history tables) from user-defined types
-- Add fields to existing types (e.g., `deletedAt` for soft delete)
-- Generate executors triggered by record events on the source type
+- Generate derived tables (e.g., archive tables, history tables) from user-defined tables
+- Add fields to existing tables (e.g., `deletedAt` for soft delete)
+- Generate executors triggered by record events on the source table
 
 ```typescript
 onTypeLoaded(context) {
@@ -102,7 +102,7 @@ onTypeLoaded(context) {
 
 ### onNamespaceLoaded
 
-**Trigger**: Called once per namespace for plugins that do not require a source type.
+**Trigger**: Called once per namespace for plugins that do not require a source table.
 
 **Context** (`PluginNamespaceProcessContext`):
 
@@ -113,11 +113,11 @@ onTypeLoaded(context) {
 
 **Returns** (`PluginOutput`):
 
-Same as `TypePluginOutput` but without `extends` (namespace plugins cannot extend a source type).
+Same as `TypePluginOutput` but without `extends` (namespace plugins cannot extend a source table).
 
 **Use cases**:
 
-- Generate types that don't derive from a specific user type (e.g., audit log, settings table)
+- Generate tables that don't derive from a specific user table (e.g., audit log, settings table)
 
 ```typescript
 onNamespaceLoaded(context) {
@@ -129,26 +129,26 @@ onNamespaceLoaded(context) {
 
 ### onTailorDBReady
 
-**Trigger**: Called once after all TailorDB types are loaded and auth is resolved.
+**Trigger**: Called once after all TailorDB tables are loaded and auth is resolved.
 
 **Context** (`TailorDBReadyContext`):
 
-| Field          | Type                      | Description                                                    |
-| -------------- | ------------------------- | -------------------------------------------------------------- |
-| `tailordb`     | `TailorDBNamespaceData[]` | All namespaces with types, source info, and plugin attachments |
-| `auth`         | `GeneratorAuthInput?`     | Auth configuration (machine users, OAuth2 clients, etc.)       |
-| `baseDir`      | `string`                  | Output directory for generated files                           |
-| `configPath`   | `string`                  | Path to `tailor.config.ts`                                     |
-| `pluginConfig` | `PluginConfig`            | Plugin-level config from `definePlugins()`                     |
+| Field          | Type                      | Description                                                     |
+| -------------- | ------------------------- | --------------------------------------------------------------- |
+| `tailordb`     | `TailorDBNamespaceData[]` | All namespaces with tables, source info, and plugin attachments |
+| `auth`         | `GeneratorAuthInput?`     | Auth configuration (machine users, OAuth2 clients, etc.)        |
+| `baseDir`      | `string`                  | Output directory for generated files                            |
+| `configPath`   | `string`                  | Path to `tailor.config.ts`                                      |
+| `pluginConfig` | `PluginConfig`            | Plugin-level config from `definePlugins()`                      |
 
 `TailorDBNamespaceData` contains:
 
-| Field               | Type                                       | Description                          |
-| ------------------- | ------------------------------------------ | ------------------------------------ |
-| `namespace`         | `string`                                   | Namespace name                       |
-| `types`             | `Record<string, TailorDBType>`             | All finalized types in the namespace |
-| `sourceInfo`        | `ReadonlyMap<string, TypeSourceInfoEntry>` | Source file info for each type       |
-| `pluginAttachments` | `ReadonlyMap<string, PluginAttachment[]>`  | Plugin configs attached to each type |
+| Field               | Type                                       | Description                           |
+| ------------------- | ------------------------------------------ | ------------------------------------- |
+| `namespace`         | `string`                                   | Namespace name                        |
+| `types`             | `Record<string, TailorDBType>`             | All finalized tables in the namespace |
+| `sourceInfo`        | `ReadonlyMap<string, TypeSourceInfoEntry>` | Source file info for each table       |
+| `pluginAttachments` | `ReadonlyMap<string, PluginAttachment[]>`  | Plugin configs attached to each table |
 
 **Returns** (`GeneratorResult`):
 
@@ -159,9 +159,9 @@ onNamespaceLoaded(context) {
 
 **Use cases**:
 
-- Generate type definitions (e.g., Kysely types, enum constants)
-- Generate seed data scaffolding from type schemas
-- Generate type lists or metadata files
+- Generate table definitions (e.g., Kysely types, enum constants)
+- Generate seed data scaffolding from table schemas
+- Generate table lists or metadata files
 
 ```typescript
 onTailorDBReady(ctx) {
@@ -276,7 +276,7 @@ import type {
 
 ## getGeneratedType Helper
 
-The SDK provides an async `getGeneratedType()` helper function to retrieve plugin-generated TailorDB types. This enables plugins and other tools to work with types generated by plugins.
+The SDK provides an async `getGeneratedType()` helper function to retrieve plugin-generated TailorDB tables. This enables plugins and other tools to work with tables generated by plugins.
 
 ```typescript
 import { join } from "node:path";
@@ -285,7 +285,7 @@ import { customer } from "./tailordb/customer";
 
 const configPath = join(import.meta.dirname, "./tailor.config.ts");
 
-// Type-attached plugin
+// Table-attached plugin
 const DeletedCustomer = await getGeneratedType(
   configPath,
   "@example/soft-delete",
@@ -301,8 +301,8 @@ const AuditLog = await getGeneratedType(configPath, "@example/audit-log", null,
 
 - `configPath`: Path to `tailor.config.ts` (absolute or relative to cwd)
 - `pluginId`: The plugin's unique identifier (e.g., `"@example/soft-delete"`)
-- `sourceType`: The TailorDB type that the plugin is attached to (`null` for namespace plugins)
-- `kind`: The generated type kind (e.g., `"archive"`, `"auditLog"`)
+- `sourceType`: The TailorDB table that the plugin is attached to (`null` for namespace plugins)
+- `kind`: The generated table kind (e.g., `"archive"`, `"auditLog"`)
 
 **How it works:**
 
@@ -311,7 +311,7 @@ const AuditLog = await getGeneratedType(configPath, "@example/audit-log", null,
 3. Auto-resolves the namespace from config
 4. Calls the plugin's `onTypeLoaded()` or `onNamespaceLoaded()` method
 5. Caches the result to avoid redundant processing
-6. Returns the generated type matching the specified kind
+6. Returns the generated table matching the specified kind
 
 ## Examples
 
@@ -341,7 +341,7 @@ function processSoftDelete(
   const { type, typeConfig, pluginConfig, namespace } = context;
   const prefix = pluginConfig?.archiveTablePrefix ?? "Deleted_";
 
-  // Generate archive type
+  // Generate archive table
   const archiveType = db
     .table(`${prefix}${type.name}`, {
       originalId: db.uuid().description("ID of the deleted record"),
@@ -355,7 +355,7 @@ function processSoftDelete(
     })
     .description(`Archive for deleted ${type.name} records`);
 
-  // Extend source type with deletedAt field
+  // Extend source table with deletedAt field
   const extendFields = {
     deletedAt: db.datetime({ optional: true }).description("Soft delete timestamp"),
   };
@@ -470,7 +470,7 @@ import type { Plugin, GeneratorResult } from "@tailor-platform/sdk";
 
 const typeListPlugin: Plugin = {
   id: "@example/type-list",
-  description: "Generates a list of all TailorDB type names",
+  description: "Generates a list of all TailorDB table names",
 
   onTailorDBReady(ctx): GeneratorResult {
     const allTypes = ctx.tailordb.flatMap((ns) =>
@@ -495,15 +495,15 @@ A plugin that uses both definition-time and generation-time hooks:
 ```typescript
 const plugin: Plugin = {
   id: "@example/hybrid",
-  description: "Generates derived types and produces output files",
+  description: "Generates derived tables and produces output files",
   importPath: "./plugins/hybrid",
 
-  // Definition-time: Generate additional types from attached source types
+  // Definition-time: Generate additional tables from attached source tables
   onTypeLoaded(context) {
     return { types: { derived: createDerivedType(context.type) } };
   },
 
-  // Generation-time: Generate output files from all finalized types
+  // Generation-time: Generate output files from all finalized tables
   onTailorDBReady(ctx) {
     const allTypes = ctx.tailordb.flatMap((ns) => Object.values(ns.types).map((t) => t.name));
     return {
@@ -539,7 +539,7 @@ const plugin: Plugin<MyTypeConfig, MyPluginConfig> = {
 };
 ```
 
-### Per-type `.plugin()` type safety (declaration merging)
+### Per-table `.plugin()` type safety (declaration merging)
 
 To enable type checking when users attach plugins via `.plugin()`, provide a declaration merge
 for the `PluginConfigs` interface. Plugin authors should ship this in their package's type definitions:
@@ -556,7 +556,7 @@ declare module "@tailor-platform/sdk" {
 }
 ```
 
-The `Fields` type parameter provides field names from the type being configured, enabling field-aware configurations:
+The `Fields` type parameter provides field names from the table being configured, enabling field-aware configurations:
 
 ```typescript
 declare module "@tailor-platform/sdk" {

package/docs/plugin/index.md

@@ -2,15 +2,15 @@
 
 > **Beta Feature**: The plugin system is currently in beta. APIs may change in future releases.
 
-Plugins extend TailorDB types by automatically generating additional types, executors, and output files based on your type definitions.
+Plugins extend TailorDB tables by automatically generating additional tables, executors, and output files based on your table definitions.
 
 ## Overview
 
 When you run `tailor generate`, the SDK:
 
-1. Loads all TailorDB types with plugin attachments
-2. Passes each type to the attached plugins
-3. Generates additional types and executors based on plugin output
+1. Loads all TailorDB tables with plugin attachments
+2. Passes each table to the attached plugins
+3. Generates additional tables and executors based on plugin output
 4. Writes all generated files to the appropriate locations
 
 This enables plugins to create derived functionality based on your application's schema.
@@ -35,9 +35,9 @@ export default defineConfig({
 
 **Important**: The `plugins` export must be a named export (not default).
 
-### Attaching Plugins to Types
+### Attaching Plugins to Tables
 
-Use the `.plugin()` method to attach plugins to specific types:
+Use the `.plugin()` method to attach plugins to specific tables:
 
 ```typescript
 import { db } from "@tailor-platform/sdk";
@@ -54,7 +54,7 @@ export const user = db
 
 ### Plugin Configuration
 
-Some plugins accept per-type configuration:
+Some plugins accept per-table configuration:
 
 ```typescript
 export const customer = db
@@ -70,9 +70,9 @@ export const customer = db
   });
 ```
 
-### Per-type Config Requirement
+### Per-table Config Requirement
 
-Per-type config is optional by default. Plugin authors can change this with
+Per-table config is optional by default. Plugin authors can change this with
 `typeConfigRequired` (boolean or function). When a function is used, it receives
 the plugin-level config from `definePlugins()`.
 
@@ -97,9 +97,9 @@ export const plugins = definePlugins(
 
 Plugins can generate:
 
-- **Types**: Additional TailorDB types (e.g., `CustomerHistory`, `Deleted_Customer`)
+- **Tables**: Additional TailorDB tables (e.g., `CustomerHistory`, `Deleted_Customer`)
 - **Executors**: Event handlers triggered by record changes
-- **Field Extensions**: Additional fields added to the source type
+- **Field Extensions**: Additional fields added to the source table
 - **Output Files**: TypeScript code and other files via generation-time hooks
 
 Generated files are placed under `.tailor/<plugin-id>/` (the plugin ID is sanitized,
@@ -115,13 +115,13 @@ Plugins have 5 hooks across two lifecycle phases. Each hook fires at a specific
 ```
 tailor generate
 │
-├─ Load TailorDB types
-│   ├─ onTypeLoaded        ← per type with .plugin() attached
+├─ Load TailorDB tables
+│   ├─ onTypeLoaded        ← per table with .plugin() attached
 │   └─ onNamespaceLoaded   ← once per namespace (namespace plugins)
 │
 ├─ Resolve Auth
 │
-├─ onTailorDBReady           ← all types finalized
+├─ onTailorDBReady           ← all tables finalized
 │
 ├─ Load Resolvers
 │
@@ -134,20 +134,20 @@ tailor generate
 
 ### Definition-time hooks
 
-| Hook                | Trigger                             | Can do                                                          |
-| ------------------- | ----------------------------------- | --------------------------------------------------------------- |
-| `onTypeLoaded`      | Each type with `.plugin()` attached | Generate types, resolvers, executors; extend source type fields |
-| `onNamespaceLoaded` | Once per namespace                  | Generate types, resolvers, executors                            |
+| Hook                | Trigger                              | Can do                                                            |
+| ------------------- | ------------------------------------ | ----------------------------------------------------------------- |
+| `onTypeLoaded`      | Each table with `.plugin()` attached | Generate tables, resolvers, executors; extend source table fields |
+| `onNamespaceLoaded` | Once per namespace                   | Generate tables, resolvers, executors                             |
 
-These hooks produce TailorDB types, resolvers, and executors that become part of the application. Requires `importPath` on the plugin.
+These hooks produce TailorDB tables, resolvers, and executors that become part of the application. Requires `importPath` on the plugin.
 
 ### Generation-time hooks
 
-| Hook              | Available data                             | Can do             |
-| ----------------- | ------------------------------------------ | ------------------ |
-| `onTailorDBReady` | TailorDB types, Auth                       | Write output files |
-| `onResolverReady` | TailorDB types, Resolvers, Auth            | Write output files |
-| `onExecutorReady` | TailorDB types, Resolvers, Executors, Auth | Write output files |
+| Hook              | Available data                              | Can do             |
+| ----------------- | ------------------------------------------- | ------------------ |
+| `onTailorDBReady` | TailorDB tables, Auth                       | Write output files |
+| `onResolverReady` | TailorDB tables, Resolvers, Auth            | Write output files |
+| `onExecutorReady` | TailorDB tables, Resolvers, Executors, Auth | Write output files |
 
 These hooks receive all finalized data and produce output files (TypeScript code, etc.). No `importPath` required.
 

package/docs/services/auth.md

@@ -6,7 +6,7 @@ Auth is a service for configuring authentication and authorization in your Tailo
 
 Auth provides:
 
-- User profile mapping to TailorDB types
+- User profile mapping to TailorDB tables
 - Machine users for service-to-service authentication
 - OAuth 2.0 client configuration
 - Identity provider integration
@@ -68,11 +68,11 @@ export default defineConfig({
 
 ## User Profile
 
-Maps authenticated identities to a TailorDB type:
+Maps authenticated identities to a TailorDB table:
 
 ```typescript
 userProfile: {
-  type: user,              // TailorDB type for user records
+  type: user,              // TailorDB table for user records
   usernameField: "email",  // Field used as username (must be unique)
   attributes: {
     role: true,            // Enable 'role' as a user attribute
@@ -80,7 +80,7 @@ userProfile: {
 },
 ```
 
-Example TailorDB type for user profile:
+Example TailorDB table for user profile:
 
 ```typescript
 // tailordb/user.ts
@@ -93,9 +93,9 @@ export const user = db.table("User", {
 });
 ```
 
-**type**: The TailorDB type that stores user records.
+**type**: The TailorDB table that stores user records.
 
-**namespace** (optional): The TailorDB namespace where the user type is defined. Usually auto-resolved from your `db` configuration, so you don't need to specify it. Required only when multiple TailorDB namespaces exist and the type lives in an external TailorDB:
+**namespace** (optional): The TailorDB namespace where the user table is defined. Usually auto-resolved from your `db` configuration, so you don't need to specify it. Required only when multiple TailorDB namespaces exist and the table lives in an external TailorDB:
 
 ```typescript
 userProfile: {
@@ -105,9 +105,9 @@ userProfile: {
 },
 ```
 
-**usernameField**: The field in the TailorDB type used as the username. This field must have a unique constraint (`.unique()`) since it is used to uniquely identify users.
+**usernameField**: The field in the TailorDB table used as the username. This field must have a unique constraint (`.unique()`) since it is used to uniquely identify users.
 
-**attributes**: Specifies which fields from the TailorDB type are used as user attributes. Set to `true` to enable a field. Machine user definitions must assign values to attributes derived from required fields; attributes derived from optional fields may be omitted (see [Machine Users](#machine-users)). Only fields with ValueOperand types (string, boolean, string[], boolean[]) can be used as attributes. The `id` field and datetime/date/time types are excluded.
+**attributes**: Specifies which fields from the TailorDB table are used as user attributes. Set to `true` to enable a field. Machine user definitions must assign values to attributes derived from required fields; attributes derived from optional fields may be omitted (see [Machine Users](#machine-users)). Only fields with ValueOperand types (string, boolean, string[], boolean[]) can be used as attributes. The `id` field and datetime/date/time types are excluded.
 
 ## Attribute List
 
@@ -122,9 +122,9 @@ userProfile: {
 },
 ```
 
-**attributeList**: An array of field names from the TailorDB type. These fields will be exposed as an ordered list of UUIDs. Only UUID-type fields (non-array) can be included in the attribute list.
+**attributeList**: An array of field names from the TailorDB table. These fields will be exposed as an ordered list of UUIDs. Only UUID-type fields (non-array) can be included in the attribute list.
 
-Example TailorDB type with UUID fields for attribute list:
+Example TailorDB table with UUID fields for attribute list:
 
 ```typescript
 // tailordb/user.ts

package/docs/services/executor.md

@@ -406,7 +406,7 @@ interface RecordCreatedContext<T> {
   rawEvent: "tailordb.type_record.created"; // Full event type string
   workspaceId: string; // Workspace identifier
   appNamespace: string; // Application/namespace name
-  typeName: string; // TailorDB type name
+  typeName: string; // TailorDB table name
   newRecord: T; // The newly created record
 }
 ```

package/docs/services/resolver.md

@@ -150,11 +150,11 @@ createResolver({
 
 This is useful when the same logical type appears in multiple resolvers or when you want a predictable, human-readable name in the generated GraphQL schema.
 
-**Warning:** Do not set `typeName` to an existing TailorDB type name on an `object()` that contains enum or nested fields. Child fields without an explicit `typeName` auto-generate names using `{parentTypeName}{FieldName}`, which can collide with the TailorDB type's own enum/nested type names.
+**Warning:** Do not set `typeName` to an existing TailorDB table name on an `object()` that contains enum or nested fields. Child fields without an explicit `typeName` auto-generate names using `{parentTypeName}{FieldName}`, which can collide with the TailorDB table's own enum/nested type names.
 
 ```typescript
 // Collision — "Item" + "status" auto-generates "ItemStatus",
-//   which collides with the TailorDB Item type's status enum
+//   which collides with the TailorDB Item table's status enum
 output: t
   .object({
     id: t.uuid(),