feat(node-sql): add SQL-based function template with example

Extracted from lucas/node-sql-template-v2 branch and adapted to
dynamic registry architecture. Changes:

- Add templates/node-sql for direct PostgreSQL access functions
- Add functions/sql-example using the node-sql template
- Add e2e test for sql-example

The node-sql template provides withUserContext() for executing
queries with proper actor context, unlike node-graphql which
uses GraphQL clients.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: theothersideofgod

functions/sql-example/__tests__/handler.test.ts

@@ -0,0 +1,88 @@
+const mockQuery = jest.fn();
+const mockRelease = jest.fn();
+
+jest.mock('pg', () => ({
+  Pool: jest.fn().mockImplementation(() => ({
+    connect: jest.fn().mockResolvedValue({
+      query: mockQuery,
+      release: mockRelease,
+    }),
+  })),
+  Client: jest.fn().mockImplementation(() => ({
+    connect: jest.fn(),
+    query: mockQuery,
+    end: jest.fn(),
+  })),
+}));
+
+const createMockContext = () => {
+  const mockClient = {
+    query: mockQuery,
+    release: mockRelease,
+  };
+
+  return {
+    job: {
+      jobId: 'test-job-id',
+      workerId: 'test-worker',
+      databaseId: 'test-db',
+    },
+    pool: {
+      connect: jest.fn().mockResolvedValue(mockClient),
+    },
+    withUserContext: jest.fn(async (_actorId: string | undefined, fn: (client: typeof mockClient) => Promise<unknown>) => {
+      return fn(mockClient);
+    }),
+    log: {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+    },
+    env: {},
+  };
+};
+
+const loadHandler = () => {
+  const mod = require('../handler');
+  return mod.default ?? mod;
+};
+
+describe('sql-example handler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockQuery.mockReset();
+  });
+
+  it('should execute default query (SELECT version()) when no query provided', async () => {
+    const handler = loadHandler();
+    const context = createMockContext();
+    mockQuery.mockResolvedValueOnce({ rows: [{ version: 'PostgreSQL 15.0' }] });
+
+    const result = await handler({}, context);
+
+    expect(result.success).toBe(true);
+    expect(result.message).toBe('Query executed successfully');
+    expect(context.withUserContext).toHaveBeenCalledWith(undefined, expect.any(Function));
+  });
+
+  it('should execute custom query', async () => {
+    const handler = loadHandler();
+    const context = createMockContext();
+    mockQuery.mockResolvedValueOnce({ rows: [{ count: 5 }] });
+
+    const result = await handler({ query: 'SELECT count(*) FROM users' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual([{ count: 5 }]);
+  });
+
+  it('should pass actor_id to withUserContext', async () => {
+    const handler = loadHandler();
+    const context = createMockContext();
+    mockQuery.mockResolvedValueOnce({ rows: [] });
+
+    await handler({ actor_id: 'user-123' }, context);
+
+    expect(context.withUserContext).toHaveBeenCalledWith('user-123', expect.any(Function));
+  });
+});

functions/sql-example/handler.json

@@ -0,0 +1,6 @@
+{
+  "name": "sql-example",
+  "version": "1.0.0",
+  "type": "node-sql",
+  "description": "Example function using node-sql template for direct PostgreSQL access"
+}

functions/sql-example/handler.ts

@@ -0,0 +1,34 @@
+import type { FunctionHandler } from './types';
+
+type Params = {
+  query?: string;
+  actor_id?: string;
+};
+
+type Result = {
+  success: boolean;
+  message: string;
+  data?: unknown;
+};
+
+const handler: FunctionHandler<Params, Result> = async (params, context) => {
+  const { log, withUserContext } = context;
+  const { query = 'SELECT version()', actor_id } = params;
+
+  log.info('[sql-example] Executing query', { query, actor_id });
+
+  const result = await withUserContext(actor_id, async (client) => {
+    const res = await client.query(query);
+    return res.rows;
+  });
+
+  log.info('[sql-example] Query complete', { rowCount: result.length });
+
+  return {
+    success: true,
+    message: 'Query executed successfully',
+    data: result,
+  };
+};
+
+export default handler;

skaffold.yaml

@@ -193,6 +193,50 @@ profiles:
         namespace: constructive-functions
         port: 3000
         localPort: 3002
+  - name: sql-example
+    build:
+      artifacts:
+        - image: constructive-functions
+          context: .
+          docker:
+            dockerfile: Dockerfile.dev
+          sync:
+            manual:
+              - src: 'functions/**/*.ts'
+                dest: /usr/src/app
+      local:
+        push: false
+    manifests:
+      kustomize:
+        paths:
+          - k8s/overlays/local-simple
+      rawYaml:
+        - generated/sql-example/k8s/local-deployment.yaml
+        - generated/sql-example/k8s/functions-configmap.yaml
+    deploy:
+      kubectl:
+        defaultNamespace: constructive-functions
+    portForward:
+      - resourceType: service
+        resourceName: sql-example
+        namespace: constructive-functions
+        port: 80
+        localPort: 8085
+      - resourceType: service
+        resourceName: knative-job-service
+        namespace: constructive-functions
+        port: 8080
+        localPort: 8080
+      - resourceType: service
+        resourceName: postgres
+        namespace: constructive-functions
+        port: 5432
+        localPort: 5432
+      - resourceType: service
+        resourceName: constructive-server
+        namespace: constructive-functions
+        port: 3000
+        localPort: 3002
 
   # All functions together.
   - name: local-simple
@@ -227,6 +271,7 @@ profiles:
         - generated/python-example/k8s/local-deployment.yaml
         - generated/send-email/k8s/local-deployment.yaml
         - generated/send-verification-link/k8s/local-deployment.yaml
+        - generated/sql-example/k8s/local-deployment.yaml
         - generated/functions-configmap.yaml
     deploy:
       kubectl:
@@ -252,6 +297,11 @@ profiles:
         namespace: constructive-functions
         port: 80
         localPort: 8082
+      - resourceType: service
+        resourceName: sql-example
+        namespace: constructive-functions
+        port: 80
+        localPort: 8085
       - resourceType: service
         resourceName: knative-job-service
         namespace: constructive-functions
@@ -307,6 +357,11 @@ profiles:
         namespace: constructive-functions
         port: 80
         localPort: 8082
+      - resourceType: service
+        resourceName: sql-example
+        namespace: constructive-functions
+        port: 80
+        localPort: 8085
       - resourceType: service
         resourceName: knative-job-service
         namespace: constructive-functions

templates/node-sql/Dockerfile

@@ -0,0 +1,20 @@
+FROM node:22-alpine AS build
+RUN npm install -g pnpm@10.12.2
+WORKDIR /app
+COPY . .
+RUN node --experimental-strip-types scripts/generate.ts \
+    && pnpm install --frozen-lockfile \
+    && pnpm --filter @constructive-io/{{name}}-fn... build
+
+FROM node:22-alpine AS deploy
+RUN npm install -g pnpm@10.12.2
+COPY --from=build /app /app
+WORKDIR /app
+RUN pnpm --filter @constructive-io/{{name}}-fn deploy --legacy /deploy --prod
+
+FROM node:22-alpine
+WORKDIR /app
+COPY --from=deploy /deploy .
+ENV NODE_ENV=production
+EXPOSE 8080
+CMD ["node", "dist/index.js"]

templates/node-sql/index.ts

@@ -0,0 +1,91 @@
+import { createJobApp } from '@constructive-io/knative-job-fn';
+import { createLogger } from '@pgpmjs/logger';
+import { Pool, PoolClient } from 'pg';
+import handler from './handler';
+
+let pool: Pool | null = null;
+
+function getPool(): Pool {
+  if (!pool) {
+    pool = new Pool({
+      host: process.env.PGHOST,
+      port: Number(process.env.PGPORT || 5432),
+      database: process.env.PGDATABASE,
+      user: process.env.PGUSER,
+      password: process.env.PGPASSWORD,
+      max: Number(process.env.PGPOOL_MAX || 10),
+      idleTimeoutMillis: Number(process.env.PGPOOL_IDLE_TIMEOUT || 30000),
+      connectionTimeoutMillis: Number(process.env.PGPOOL_CONNECTION_TIMEOUT || 5000),
+    });
+  }
+  return pool;
+}
+
+function createWithUserContext(pool: Pool, databaseId: string | undefined) {
+  return async function withUserContext<T>(
+    actorId: string | undefined,
+    fn: (client: PoolClient) => Promise<T>
+  ): Promise<T> {
+    const client = await pool.connect();
+    try {
+      await client.query('BEGIN');
+
+      if (databaseId) {
+        await client.query(`SELECT set_config('jwt.claims.database_id', $1, true)`, [databaseId]);
+      }
+      if (actorId) {
+        await client.query(`SELECT set_config('jwt.claims.user_id', $1, true)`, [actorId]);
+        await client.query('SET LOCAL ROLE authenticated');
+      }
+
+      const result = await fn(client);
+
+      await client.query('COMMIT');
+      return result;
+    } catch (err) {
+      try {
+        await client.query('ROLLBACK');
+      } catch {
+        // Ignore rollback errors
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  };
+}
+
+const app = createJobApp();
+const log = createLogger('{{name}}');
+
+app.post('/', async (req: any, res: any, next: any) => {
+  try {
+    const databaseId = req.get('X-Database-Id') || req.get('x-database-id') || process.env.DEFAULT_DATABASE_ID;
+    const currentPool = getPool();
+
+    const context = {
+      job: {
+        jobId: req.get('X-Job-Id') || req.get('x-job-id'),
+        workerId: req.get('X-Worker-Id') || req.get('x-worker-id'),
+        databaseId,
+      },
+      pool: currentPool,
+      withUserContext: createWithUserContext(currentPool, databaseId),
+      log,
+      env: process.env as Record<string, string | undefined>,
+    };
+
+    const params = req.body || {};
+    const result = await handler(params, context);
+
+    res.status(200).json(result);
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default app;
+
+if (require.main === module) {
+  app.listen(Number(process.env.PORT || 8080));
+}

templates/node-sql/k8s/knative-service.yaml

@@ -0,0 +1,27 @@
+apiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: {{name}}
+  namespace: constructive-functions
+spec:
+  template:
+    spec:
+      containers:
+        - image: ghcr.io/constructive-io/{{name}}-fn:latest
+          ports:
+            - containerPort: 8080
+          envFrom:
+            - secretRef:
+                name: pg-credentials
+          env:
+            - name: NODE_ENV
+              value: "production"
+            - name: LOG_LEVEL
+              value: "info"
+          resources:
+            requests:
+              memory: "128Mi"
+              cpu: "100m"
+            limits:
+              memory: "512Mi"
+              cpu: "500m"