feat: Update template to RDF-Connect v2

Author: smessie

.github/workflows/build-test.yml

@@ -16,9 +16,9 @@ jobs:
             - name: Setup Node.js
               uses: actions/setup-node@v3
               with:
-                  node-version: 21.x
+                  node-version: 24.x
                   cache: "npm"
 
-            - run: npm ci
+            - run: npm i
             - run: npm run build
             - run: npm run test

README.md

@@ -2,39 +2,121 @@
 
 [![Build and tests with Node.js](https://github.com/rdf-connect/template-processor-ts/actions/workflows/build-test.yml/badge.svg)](https://github.com/rdf-connect/template-processor-ts/actions/workflows/build-test.yml)
 
-This repository contains a fully functioning dummy implementation of a logging processor written in TypeScript, meant to be used as a template in order to kickstart the development of your next processor.
+Template processor to kickstart the development of your next JavaScript/TypeScript RDF-Connect processor.
 
-## Features
+## Usage
 
-At the time of writing, this repositories sets up the following boilerplate and tools for you.
+To use the TypeScript TemplateProcessor in your RDF-Connect pipeline, you need to have a pipeline configuration that includes the [rdfc:NodeRunner](https://github.com/rdf-connect/js-runner) (check out their documentation to find out how to install and configure it).
 
-- Placeholder implementation of a processor which accepts input from a stream, logs it to the console, and pipes it back into the outgoing stream.
-- An initial `processor.ttl` file.
-- Vitest configuration unit testing, including GitHub Actions configuration.
-- Renovate notifications for dependency updates.
-- Convenient publishing to GitHub Packages for every new release.
-- ESLint/Prettier linting and styling, including a Husky git hook in combination with lint-staged.
-- The MIT license.
+Next, you can add the JS/TS TemplateProcessor to your pipeline configuration as follows:
 
-## Installation
+```turtle
+@prefix rdfc: <https://w3id.org/rdf-connect#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
 
+# Import the processor
+<> owl:imports <./node_modules/@rdfc/template-processor-ts/processor.ttl>.
+
+### Define the channels your processor needs
+<channel1> a rdfc:Writer, rdfc:Reader.
+<channel2> a rdfc:Writer, rdfc:Reader.
+
+# Attach the processor to the pipeline under the NodeRunner
+# Add the `rdfc:processor <template>` statement under the `rdfc:consistsOf` statement of the `rdfc:NodeRunner`
+
+# Define and configure the processor
+<template> a rdfc:TemplateProcessorJs;
+      rdfc:reader <channel1>;
+      rdfc:writer <channel2>".
 ```
+
+## Development
+
+To start developing your own JavaScript/TypeScript processor based on this template, you can click the "Use this template" button on the top right of this page to create a new repository based on this template.
+
+You can then clone your newly created repository and start implementing your own processor logic in the `src/index.ts` file.
+
+First, install the dependencies using the following command:
+
+```bash
 npm install
-npm run build
 ```
 
-## Example
+You can run the tests using:
 
-An example configuration of the processor can be found in the `example` directory.
+```bash
+npm test
+```
 
-You can run this example by executing the following command:
+You can build the project using:
 
 ```bash
-npx @rdfc/js-runner example/pipeline.ttl
+npm run build
 ```
 
-To enable all debug logs, add `DEBUG=*` before the command:
+### Logging
 
-```bash
-DEBUG=* npx @rdfc/js-runner example/pipeline.ttl
+The JavaScript runner and processors use the `winston` logging library for logging.
+The JavasScript runner initiates a logger that is passed to each processor, allowing them to log messages at various levels (info, warn, error, debug).
+You can access this logger in your processor class code on the `this.logger` property.
+Here's an example of how to use the logger in a processor:
+
+```typescript
+import { Processor } from '@rdfc/js-runner'
+
+class MyProcessor extends Processor<MyProcessorArgs> {
+  async init(this: MyProcessorArgs & this): Promise<void> {
+    this.logger.info('I am initializing my processor!')
+  }
+  // ...
+}
+```
+
+This logger is configured to forward log messages to the RDF-Connect logging system.
+This means you can view and manage these logs in the RDF-Connect logging interface, allowing for consistent log management across different components of your RDF-Connect pipeline.
+
+If you want to create a child logger for a subclass or submethod, you can do so using the `extendLogger` method.
+Here's an example:
+
+```typescript
+import { Processor, extendLogger } from '@rdfc/js-runner'
+
+class MyProcessor extends Processor<MyProcessorArgs> {
+  async init(this: MyProcessorArgs & this): Promise<void> {
+    const childLogger = extendLogger(this.logger, 'init')
+    childLogger.debug('This is a debug message from init.')
+  }
+  // ...
+}
 ```
+
+
+### Project Structure
+
+```
+template-processor-ts/      # Root directory of the project
+├── .github/                # CI/CD configuration files for GitHub Actions and Renovate dependency updates
+├── src/                    # Source code directory
+│   └── index.ts            # Contains the main logic for the JS/TS processor
+├── tests/                  # Directory for unit tests
+│   ├── index.test.ts       # Functional tests for the processor logic
+│   └── processor.test.ts   # Processor initialization tests
+├── package.json            # Project metadata and dependencies
+├── tsconfig.json           # TypeScript configuration file
+└── processor.ttl           # RDF schema for the processor, used for metadata and configuration
+```
+
+
+### Next Steps
+
+You can start developing your own TypeScript processor by modifying the `src/index.ts` file.
+This file contains the main logic for the processor and is where you can implement your custom processing logic.
+
+You probably want to modify the next things to make this template your own:
+- Change the repository package name and description in the `package.json` file.
+- Change the processor class name in the `src/index.ts` file.
+- Update the `processor.ttl` file to reflect the new processor name and any additional metadata or parameters.
+- Install any additional dependencies you might need for your processor using `npm install <package-name>`.
+- Implement your custom processing logic in the `init`, `transform`, and `produce` methods of the processor class.
+- Add unit tests for your processor in the `tests/` directory to ensure your processor works as expected.
+- Update this README file to reflect your processor's functionality and usage instructions.