@harperfast/template-react-studio 1.2.2 → 1.3.0

package/.agents/skills/harper-best-practices/rules/defining-relationships.md

@@ -0,0 +1,33 @@
+---
+name: defining-relationships
+description: How to define and use relationships between tables in Harper using GraphQL.
+---
+
+# Defining Relationships
+
+Instructions for the agent to follow when defining relationships between Harper tables.
+
+## When to Use
+
+Use this skill when you need to link data across different tables, enabling automatic joins and efficient related-data fetching via REST APIs.
+
+## Steps
+
+1. **Identify the Relationship Type**: Determine if it's one-to-one, many-to-one, or one-to-many.
+2. **Use the `@relationship` Directive**: Apply it to a field in your GraphQL schema.
+   - **Many-to-One (Current table holds FK)**: Use `from`.
+     ```graphql
+     type Book @table @export {
+     	authorId: ID
+     	author: Author @relationship(from: "authorId")
+     }
+     ```
+   - **One-to-Many (Related table holds FK)**: Use `to` and an array type.
+     ```graphql
+     type Author @table @export {
+     	books: [Book] @relationship(to: "authorId")
+     }
+     ```
+3. **Query with Relationships**: Use dot syntax in REST API calls for filtering or the `select()` operator for including related data.
+   - Example Filter: `GET /Book/?author.name=Harper`
+   - Example Select: `GET /Author/?select(name,books(title))`

package/.agents/skills/harper-best-practices/rules/deploying-to-harper-fabric.md

@@ -0,0 +1,24 @@
+---
+name: deploying-to-harper-fabric
+description: How to deploy a Harper application to the Harper Fabric cloud.
+---
+
+# Deploying to Harper Fabric
+
+Instructions for the agent to follow when deploying to Harper Fabric.
+
+## When to Use
+
+Use this skill when you are ready to move your Harper application from local development to a cloud-hosted environment.
+
+## Steps
+
+1. **Sign up**: Create an account at [https://fabric.harper.fast/](https://fabric.harper.fast/) and create a cluster.
+2. **Configure Environment**: Add your cluster credentials and cluster application URL to `.env`:
+   ```bash
+   CLI_TARGET_USERNAME='YOUR_CLUSTER_USERNAME'
+   CLI_TARGET_PASSWORD='YOUR_CLUSTER_PASSWORD'
+   CLI_TARGET='YOUR_CLUSTER_URL'
+   ```
+3. **Deploy From Local Environment**: Run `npm run deploy`.
+4. **Set up CI/CD**: Configure `.github/workflows/deploy.yaml` and set repository secrets for automated deployments.

package/.agents/skills/harper-best-practices/rules/extending-tables.md

@@ -0,0 +1,37 @@
+---
+name: extending-tables
+description: How to add custom logic to automatically generated table resources in Harper.
+---
+
+# Extending Tables
+
+Instructions for the agent to follow when extending table resources in Harper.
+
+## When to Use
+
+Use this skill when you need to add custom validation, side effects (like webhooks), data transformation, or custom access control to the standard CRUD operations of a Harper table.
+
+## Steps
+
+1. **Define the Table in GraphQL**: In your `.graphql` schema, define the table using the `@table` directive. **Do not** use `@export` if you plan to extend it.
+   ```graphql
+   type MyTable @table {
+   	id: ID @primaryKey
+   	name: String
+   }
+   ```
+2. **Create the Extension File**: Create a `.ts` file in your `resources/` directory.
+3. **Extend the Table Resource**: Export a class that extends `tables.YourTableName`:
+   ```typescript
+   import { type RequestTargetOrId, tables } from 'harperdb';
+
+   export class MyTable extends tables.MyTable {
+   	async post(target: RequestTargetOrId, record: any) {
+   		// Custom logic here
+   		if (!record.name) { throw new Error('Name required'); }
+   		return super.post(target, record);
+   	}
+   }
+   ```
+4. **Override Methods**: Override `get`, `post`, `put`, `patch`, or `delete` as needed. Always call `super[method]` to maintain default Harper functionality unless you intend to replace it entirely.
+5. **Implement Logic**: Use overrides for validation, side effects, or transforming data before/after database operations.

package/.agents/skills/harper-best-practices/rules/handling-binary-data.md

@@ -0,0 +1,43 @@
+---
+name: handling-binary-data
+description: How to store and serve binary data like images or audio in Harper.
+---
+
+# Handling Binary Data
+
+Instructions for the agent to follow when handling binary data in Harper.
+
+## When to Use
+
+Use this skill when you need to store binary files (images, audio, etc.) in the database or serve them back to clients via REST endpoints.
+
+## Steps
+
+1. **Store Base64 as Blobs**: In your resource's `post` or `put` method, convert incoming base64 strings to Buffers and then to Blobs using `createBlob`:
+   ```typescript
+   import { createBlob } from 'harperdb';
+
+   async post(target, record) {
+     if (record.data) {
+       record.data = createBlob(Buffer.from(record.data, 'base64'), {
+         type: 'image/jpeg',
+       });
+     }
+     return super.post(target, record);
+   }
+   ```
+2. **Serve Binary Data**: In your resource's `get` method, return a response object with the appropriate `Content-Type` and the binary data in the `body`:
+   ```typescript
+   async get(target) {
+     const record = await super.get(target);
+     if (record?.data) {
+       return {
+         status: 200,
+         headers: { 'Content-Type': 'image/jpeg' },
+         body: record.data,
+       };
+     }
+     return record;
+   }
+   ```
+3. **Use the Blob Type**: Ensure your GraphQL schema uses the `Blob` scalar for binary fields.

package/.agents/skills/harper-best-practices/rules/programmatic-table-requests.md

@@ -0,0 +1,39 @@
+---
+name: programmatic-table-requests
+description: How to interact with Harper tables programmatically using the `tables` object.
+---
+
+# Programmatic Table Requests
+
+Instructions for the agent to follow when interacting with Harper tables via code.
+
+## When to Use
+
+Use this skill when you need to perform database operations (CRUD, search, subscribe) from within Harper Resources or scripts.
+
+## Steps
+
+1. **Access the Table**: Use the global `tables` object followed by your table name (e.g., `tables.MyTable`).
+2. **Perform CRUD Operations**:
+   - **Get**: `await tables.MyTable.get(id)` for a single record or `await tables.MyTable.get({ conditions: [...] })` for multiple.
+   - **Create**: `await tables.MyTable.post(record)` (auto-generates ID) or `await tables.MyTable.put(id, record)`.
+   - **Update**: `await tables.MyTable.patch(id, partialRecord)` for partial updates.
+   - **Delete**: `await tables.MyTable.delete(id)`.
+3. **Use Updatable Records for Atomic Ops**: Call `update(id)` to get a reference, then use `addTo` or `subtractFrom` for atomic increments/decrements:
+   ```typescript
+   const stats = await tables.Stats.update('daily');
+   stats.addTo('viewCount', 1);
+   ```
+4. **Search and Stream**: Use `search(query)` for efficient streaming of large result sets:
+   ```typescript
+   for await (const record of tables.MyTable.search({ conditions: [...] })) {
+     // process record
+   }
+   ```
+5. **Real-time Subscriptions**: Use `subscribe(query)` to listen for changes:
+   ```typescript
+   for await (const event of tables.MyTable.subscribe(query)) {
+   	// handle event
+   }
+   ```
+6. **Publish Events**: Use `publish(id, message)` to trigger subscriptions without necessarily persisting data.

package/.agents/skills/harper-best-practices/rules/querying-rest-apis.md

@@ -0,0 +1,22 @@
+---
+name: querying-rest-apis
+description: How to use query parameters to filter, sort, and paginate Harper REST APIs.
+---
+
+# Querying REST APIs
+
+Instructions for the agent to follow when querying Harper's REST APIs.
+
+## When to Use
+
+Use this skill when you need to perform advanced data retrieval (filtering, sorting, pagination, joins) using Harper's automatic REST endpoints.
+
+## Steps
+
+1. **Basic Filtering**: Use attribute names as query parameters: `GET /Table/?key=value`.
+2. **Use Comparison Operators**: Append operators like `gt`, `ge`, `lt`, `le`, `ne` using FIQL-style syntax: `GET /Table/?price=gt=100`.
+3. **Apply Logic and Grouping**: Use `&` for AND, `|` for OR, and `()` for grouping: `GET /Table/?(rating=5|featured=true)&price=lt=50`.
+4. **Select Specific Fields**: Use `select()` to limit returned attributes: `GET /Table/?select(name,price)`.
+5. **Paginate Results**: Use `limit(count)` or `limit(offset, count)`: `GET /Table/?limit(20, 10)`.
+6. **Sort Results**: Use `sort()` with `+` (asc) or `-` (desc): `GET /Table/?sort(-price,+name)`.
+7. **Query Relationships**: Use dot syntax for tables linked with `@relationship`: `GET /Book/?author.name=Harper`.

package/.agents/skills/harper-best-practices/rules/real-time-apps.md

@@ -0,0 +1,37 @@
+---
+name: real-time-apps
+description: How to build real-time features in Harper using WebSockets and Pub/Sub.
+---
+
+# Real-time Applications
+
+Instructions for the agent to follow when building real-time applications in Harper.
+
+## When to Use
+
+Use this skill when you need to stream live updates to clients, implement chat features, or provide real-time data synchronization between the database and a frontend.
+
+## Steps
+
+1. **Check Automatic WebSockets**: If you only need to stream table changes, use [Automatic APIs](automatic-apis.md) which provide a WebSocket endpoint for every `@export`ed table.
+2. **Implement `connect` in a Resource**: For custom bi-directional logic, implement the `connect` method:
+   ```typescript
+   import { Resource, tables } from 'harperdb';
+
+   export class MySocket extends Resource {
+   	async *connect(target, incomingMessages) {
+   		// Subscribe to table changes
+   		const subscription = await tables.MyTable.subscribe(target);
+   		if (!incomingMessages) { return subscription; // SSE mode
+   		 }
+
+   		// Handle incoming client messages
+   		for await (let message of incomingMessages) {
+   			yield { received: message };
+   		}
+   	}
+   }
+   ```
+3. **Use Pub/Sub**: Use `tables.TableName.subscribe(query)` to listen for specific data changes and stream them to the client.
+4. **Handle SSE**: Ensure your `connect` method gracefully handles cases where `incomingMessages` is null (Server-Sent Events).
+5. **Connect from Client**: Use standard WebSockets (`new WebSocket('ws://...')`) to connect to your resource endpoint.

package/.agents/skills/harper-best-practices/rules/serving-web-content.md

@@ -0,0 +1,34 @@
+---
+name: serving-web-content
+description: How to serve static files and integrated Vite/React applications in Harper.
+---
+
+# Serving Web Content
+
+Instructions for the agent to follow when serving web content from Harper.
+
+## When to Use
+
+Use this skill when you need to serve a frontend (HTML, CSS, JS, or a React app) directly from your Harper instance.
+
+## Steps
+
+1. **Choose a Method**: Decide between the simple Static Plugin or the integrated Vite Plugin.
+2. **Option A: Static Plugin (Simple)**:
+   - Add to `config.yaml`:
+     ```yaml
+     static:
+       files: 'web/*'
+     ```
+   - Place files in a `web/` folder in the project root.
+   - Files are served at the root URL (e.g., `http://localhost:9926/index.html`).
+3. **Option B: Vite Plugin (Advanced/Development)**:
+   - Add to `config.yaml`:
+     ```yaml
+     '@harperfast/vite-plugin':
+       package: '@harperfast/vite-plugin'
+     ```
+   - Ensure `vite.config.ts` and `index.html` are in the project root.
+   - Install dependencies: `npm install --save-dev vite @harperfast/vite-plugin`.
+   - Use `npm run dev` for development with HMR.
+4. **Deploy for Production**: For Vite apps, use a build script to generate static files into a `web/` folder and deploy them using the static handler pattern.

package/.agents/skills/harper-best-practices/rules/typescript-type-stripping.md

@@ -0,0 +1,32 @@
+---
+name: typescript-type-stripping
+description: How to run TypeScript files directly in Harper without a build step.
+---
+
+# TypeScript Type Stripping
+
+Instructions for the agent to follow when using TypeScript in Harper.
+
+## When to Use
+
+Use this skill when you want to write Harper Resources in TypeScript and have them execute directly in Node.js without an intermediate build or compilation step.
+
+## Steps
+
+1. **Verify Node.js Version**: Ensure you are using Node.js v22.6.0 or higher.
+2. **Name Files with `.ts`**: Create your resource files in the `resources/` directory with a `.ts` extension.
+3. **Use TypeScript Syntax**: Write your resource classes using standard TypeScript (interfaces, types, etc.).
+   ```typescript
+   import { Resource } from 'harperdb';
+   export class MyResource extends Resource {
+   	async get(): Promise<{ message: string }> {
+   		return { message: 'Running TS directly!' };
+   	}
+   }
+   ```
+4. **Use Explicit Extensions in Imports**: When importing other local modules, include the `.ts` extension: `import { helper } from './helper.ts'`.
+5. **Configure `config.yaml`**: Ensure `jsResource` points to your `.ts` files:
+   ```yaml
+   jsResource:
+     files: 'resources/*.ts'
+   ```

package/.agents/skills/harper-best-practices/rules/using-blob-datatype.md

@@ -0,0 +1,36 @@
+---
+name: using-blob-datatype
+description: How to use the Blob data type for efficient binary storage in Harper.
+---
+
+# Using Blob Datatype
+
+Instructions for the agent to follow when working with the Blob data type in Harper.
+
+## When to Use
+
+Use this skill when you need to store unstructured or large binary data (media, documents) that is too large for standard JSON fields. Blobs provide efficient storage and integrated streaming support.
+
+## Steps
+
+1. **Define Blob Fields**: In your GraphQL schema, use the `Blob` type:
+   ```graphql
+   type MyTable @table {
+   	id: ID @primaryKey
+   	data: Blob
+   }
+   ```
+2. **Create and Store Blobs**: Use `createBlob()` from `harperdb` to wrap Buffers or Streams:
+   ```javascript
+   import { createBlob, tables } from 'harperdb';
+   const blob = createBlob(largeBuffer);
+   await tables.MyTable.put('my-id', { data: blob });
+   ```
+3. **Use Streaming (Optional)**: For very large files, pass a stream to `createBlob()` to avoid loading the entire file into memory.
+4. **Read Blob Data**: Retrieve the record and use `.bytes()` or streaming interfaces on the blob field:
+   ```javascript
+   const record = await tables.MyTable.get('my-id');
+   const buffer = await record.data.bytes();
+   ```
+5. **Ensure Write Completion**: Use `saveBeforeCommit: true` in `createBlob` options if you need the blob fully written before the record is committed.
+6. **Handle Errors**: Attach error listeners to the blob object to handle streaming failures.

package/.agents/skills/harper-best-practices/rules/vector-indexing.md

@@ -0,0 +1,152 @@
+---
+name: vector-indexing
+description: How to enable and query vector indexes for similarity search in Harper.
+---
+
+# Vector Indexing
+
+Instructions for the agent to follow when implementing vector search in Harper.
+
+## When to Use
+
+Use this skill when you need to perform similarity searches on high-dimensional data, such as AI embeddings for semantic search, recommendations, or image retrieval.
+
+## Steps
+
+1. **Enable Vector Indexing**: In your GraphQL schema, add `@indexed(type: "HNSW")` to a numeric array field:
+   ```graphql
+   type Product @table {
+   	id: ID @primaryKey
+   	textEmbeddings: [Float] @indexed(type: "HNSW")
+   }
+   ```
+2. **Configure Index Options (Optional)**: Fine-tune the index with parameters like `distance` (`cosine` or `euclidean`), `M`, and `efConstruction`.
+3. **Query with Vector Search**: Use `tables.Table.search()` with a `sort` object containing the `target` vector:
+   ```javascript
+   const results = await tables.Product.search({
+     select: ['name', '$distance'],
+     sort: {
+       attribute: 'textEmbeddings',
+       target: [0.1, 0.2, ...], // query vector
+     },
+     limit: 5,
+   });
+   ```
+4. **Filter by Distance**: Use `conditions` with a `target` vector and a `comparator` (e.g., `lt`) to return results within a similarity threshold:
+   ```javascript
+   const results = await tables.Product.search({
+   	conditions: {
+   		attribute: 'textEmbeddings',
+   		comparator: 'lt',
+   		value: 0.1,
+   		target: searchVector,
+   	},
+   });
+   ```
+5. **Generate Embeddings**: Use external services (OpenAI, Ollama) to generate the numeric vectors before storing or searching them in Harper.
+
+const { Product } = tables;
+
+import OpenAI from 'openai';
+const openai = new OpenAI();
+// the name of the OpenAI embedding model
+const OPENAI_EMBEDDING_MODEL = 'text-embedding-3-small';
+
+const SIMILARITY_THRESHOLD = 0.5;
+
+export class ProductSearch extends Resource {
+// based on env variable we choose the appropriate embedding generator
+generateEmbedding = process.env.EMBEDDING_GENERATOR === 'ollama'
+? this._generateOllamaEmbedding
+: this._generateOpenAIEmbedding;
+
+    /**
+     * Executes a search query using a generated text embedding and returns the matching products.
+     *
+     * @param {Object} data - The input data for the request.
+     * @param {string} data.prompt - The prompt to generate the text embedding from.
+     * @return {Promise<Array>} Returns a promise that resolves to an array of products matching the conditions,
+     * including fields: name, description, price, and $distance.
+     */
+    async post(data) {
+    	const embedding = await this.generateEmbedding(data.prompt);
+
+    	return await Product.search({
+    		select: ['name', 'description', 'price', '$distance'],
+    		conditions: {
+    			attribute: 'textEmbeddings',
+    			comparator: 'lt',
+    			value: SIMILARITY_THRESHOLD,
+    			target: embedding[0],
+    		},
+    		limit: 5,
+    	});
+    }
+
+    /**
+     * Generates an embedding using the Ollama API.
+     *
+     * @param {string} promptData - The input data for which the embedding is to be generated.
+     * @return {Promise<number[][]>} A promise that resolves to the generated embedding as an array of numbers.
+     */
+    async _generateOllamaEmbedding(promptData) {
+    	const embedding = await ollama.embed({
+    		model: OLLAMA_EMBEDDING_MODEL,
+    		input: promptData,
+    	});
+    	return embedding?.embeddings;
+    }
+
+    /**
+     * Generates OpenAI embeddings based on the given prompt data.
+     *
+     * @param {string} promptData - The input data used for generating the embedding.
+     * @return {Promise<number[][]>} A promise that resolves to an array of embeddings, where each embedding is an array of floats.
+     */
+    async _generateOpenAIEmbedding(promptData) {
+    	const embedding = await openai.embeddings.create({
+    		model: OPENAI_EMBEDDING_MODEL,
+    		input: promptData,
+    		encoding_format: 'float',
+    	});
+
+    	let embeddings = [];
+    	embedding.data.forEach((embeddingData) => {
+    		embeddings.push(embeddingData.embedding);
+    	});
+
+    	return embeddings;
+    }
+
+}
+
+````
+Sample request to the `ProductSearch` resource which prompts to find "shorts for the gym":
+
+```bash
+curl -X POST "http://localhost:9926/ProductSearch/" \
+-H "accept: \
+-H "Content-Type: application/json" \
+-H "Authorization: Basic <YOUR_AUTH>" \
+-d '{"prompt": "shorts for the gym"}'
+````
+
+---
+
+## When to Use Vector Indexing
+
+Vector indexing is ideal when:
+
+- Storing embedding vectors from ML models
+- Performing semantic or similarity-based search
+- Working with high-dimensional numeric data
+- Exact-match indexes are insufficient
+
+---
+
+## Summary
+
+- Vector indexing enables fast similarity search on numeric arrays
+- Defined using `@indexed(type: "HNSW")`
+- Queried using a target vector in search sorting
+- Tunable for performance and accuracy

package/README.md

@@ -11,7 +11,7 @@ Here's what you should do next:
 3. Save your changes.
 4. Tap "Restart Cluster" and your changes will be live!
 
-These schemas are the heart of a great Harper app, specifying which tables you want and what attributes/fields they should have. Any table you `@export` stands up [REST endpoints automatically](./skills/automatic-rest-apis.md).
+These schemas are the heart of a great Harper app, specifying which tables you want and what attributes/fields they should have. Any table you `@export` stands up [endpoints automatically](./.agents/skills/harper-best-practices/rules/automatic-apis.md).
 
 ### Add Custom Endpoints
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@harperfast/template-react-studio",
-	"version": "1.2.2",
+	"version": "1.3.0",
 	"type": "module",
 	"repository": "github:HarperFast/create-harper",
 	"scripts": {},

package/resources/README.md

@@ -1,11 +1,11 @@
 # Resources
 
-The [schemas you define in .GraphQL files](../skills/adding-tables-with-schemas.md) will [automatically stand-up REST APIs](../skills/automatic-apis.md).
+The [schemas you define in .GraphQL files](../.agents/skills/harper-best-practices/rules/adding-tables-with-schemas.md) will [automatically stand-up REST APIs](../.agents/skills/harper-best-practices/rules/automatic-apis.md).
 
-But you can [extend your tables with custom logic](../skills/extending-tables.md) and [create your own resources](../skills/custom-resources.md) in this directory.
+But you can [extend your tables with custom logic](../.agents/skills/harper-best-practices/rules/extending-tables.md) and [create your own resources](../.agents/skills/harper-best-practices/rules/custom-resources.md) in this directory.
 
 ## Want to read more?
 
 Check out the rest of the "skills" documentation!
 
-[AGENTS.md](../AGENTS.md)
+[Harper Best Practices Skill](../.agents/skills/harper-best-practices/SKILL.md)

package/schemas/README.md

@@ -2,10 +2,10 @@
 
 Your schemas are defined in `.graphql` files within this `schemas` directory. These files contain the structure and types for your database tables, allowing Harper to automatically generate REST APIs for CRUD operations.
 
-Take a look at the [Adding Tables with Schemas](../skills/adding-tables-with-schemas.md) to learn more!
+Take a look at the [Adding Tables with Schemas](../.agents/skills/harper-best-practices/rules/adding-tables-with-schemas.md) to learn more!
 
 ## Want to read more?
 
 Check out the rest of the "skills" documentation!
 
-[AGENTS.md](../AGENTS.md)
+[Harper Best Practices Skill](../.agents/skills/harper-best-practices/SKILL.md)

package/skills-lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skills": {
+    "harper-best-practices": {
+      "source": "harperfast/skills",
+      "sourceType": "github",
+      "computedHash": "60af017817f78d6ef938b03b5ed9b301dd71655804c3ec43cf8b5a9e3109acd2"
+    }
+  }
+}

package/AGENTS.md

@@ -1,22 +0,0 @@
-# Harper Agent Skills
-
-This repository contains "skills" that guide AI agents in developing Harper applications.
-
-## Available Skills
-
-- [Adding Tables with Schemas](skills/adding-tables-with-schemas.md): Learn how to define schemas and enable automatic REST APIs for your database tables with schema .graphql files in Harper.
-- [Automatic APIs](skills/automatic-apis.md): Details on the CRUD endpoints automatically generated for exported tables with REST and WebSockets.
-- [Caching](skills/caching.md): How caching is defined and implemented in Harper applications.
-- [Checking Authentication](skills/checking-authentication.md): How to use sessions to verify user identity and roles.
-- [Custom Resources](skills/custom-resources.md): How to define custom REST endpoints using JavaScript or TypeScript (Note: Paths are case-sensitive).
-- [Defining Relationships](skills/defining-relationships.md): Using the `@relationship` directive to link tables.
-- [Deploying to Harper Fabric](skills/deploying-to-harper-fabric.md): Globally scaling your Harper application with our generous Free tier and beyond.
-- [Extending Table Resources](skills/extending-tables.md): Adding custom logic to automatically generated table resources.
-- [Handling Binary Data](skills/handling-binary-data.md): How to store and serve binary data like images or MP3s.
-- [Programmatic Table Requests](skills/programmatic-table-requests.md): How to use filters, operators, sorting, and pagination in programmatic table requests.
-- [Querying REST APIs](skills/querying-rest-apis.md): How to use filters, operators, sorting, and pagination in REST requests.
-- [Real-time Applications](skills/real-time-apps.md): Implementing WebSockets and Pub/Sub for live data updates.
-- [Serving Web Content](skills/serving-web-content): Two ways to serve web content from a Harper application.
-- [TypeScript Type Stripping](skills/typescript-type-stripping.md): Using TypeScript directly without build tools via Node.js Type Stripping.
-- [Using Blobs](skills/using-blob-datatype.md): How to store and retrieve large data in HarperDB.
-- [Vector Indexing](skills/vector-indexing.md): How to define and use vector indexes for efficient similarity search.

package/skills/adding-tables-with-schemas.md

@@ -1,34 +0,0 @@
-# Adding Tables to Harper
-
-To add tables to a Harper database, follow these guidelines:
-
-1. **Dedicated Schema Files**: Prefer having a dedicated schema `.graphql` file for each table. Check the `config.yaml` file under `graphqlSchema.files` to see how it's configured. It typically accepts wildcards (e.g., `schemas/*.graphql`), but may be configured to point at a single file.
-
-2. **Directives**: All available directives for defining your schema are defined in `node_modules/harperdb/schema.graphql`. Common directives include `@table`, `@export`, `@primaryKey`, `@indexed`, and `@relationship`.
-
-3. **Defining Relationships**: You can link tables together using the `@relationship` directive. For more details, see the [Defining Relationships](defining-relationships.md) skill.
-
-4. **Automatic APIs**: If you add `@table @export` to a schema type, Harper automatically sets up REST and WebSocket APIs for basic CRUD operations against that table. For a detailed list of available endpoints and how to use them, see the [Automatic REST APIs](automatic-apis.md) skill.
-
-   - `GET /{TableName}`: Describes the schema itself.
-   - `GET /{TableName}/`: Lists all records (supports filtering, sorting, and pagination via query parameters). See the [Querying REST APIs](querying-rest-apis.md) skill for details.
-   - `GET /{TableName}/{id}`: Retrieves a single record by its ID.
-   - `POST /{TableName}/`: Creates a new record.
-   - `PUT /{TableName}/{id}`: Updates an existing record.
-   - `PATCH /{TableName}/{id}`: Performs a partial update on a record.
-   - `DELETE /{TableName}/`: Deletes all records or filtered records.
-   - `DELETE /{TableName}/{id}`: Deletes a single record by its ID.
-
-### Example
-
-In `schemas/ExamplePerson.graphql`:
-
-```graphql
-type ExamplePerson @table @export {
-	id: ID @primaryKey
-	name: String
-	tag: String @indexed
-}
-```
-
-Tip: if you are going to [extend the table](./extending-tables.md) in your resources, then do not `@export` the table from the schema.