@pikku/cli 0.12.28 → 0.12.30

package/dist/src/functions/db/postgres/postgres-introspector.js

@@ -60,6 +60,49 @@ export class PostgresIntrospector {
             generated: r.is_generated === 'ALWAYS',
         }));
     }
+    async getForeignKeys(table) {
+        const dotIdx = table.indexOf('.');
+        const schema = dotIdx >= 0 ? table.slice(0, dotIdx) : 'public';
+        const tableName = dotIdx >= 0 ? table.slice(dotIdx + 1) : table;
+        const result = await this.client.query(`SELECT kcu.column_name,
+              kcu2.table_schema  AS foreign_table_schema,
+              kcu2.table_name   AS foreign_table_name,
+              kcu2.column_name  AS foreign_column_name
+       FROM information_schema.referential_constraints rc
+       JOIN information_schema.key_column_usage kcu
+         ON kcu.constraint_catalog = rc.constraint_catalog
+        AND kcu.constraint_schema  = rc.constraint_schema
+        AND kcu.constraint_name    = rc.constraint_name
+       JOIN information_schema.key_column_usage kcu2
+         ON kcu2.constraint_catalog = rc.unique_constraint_catalog
+        AND kcu2.constraint_schema  = rc.unique_constraint_schema
+        AND kcu2.constraint_name    = rc.unique_constraint_name
+        AND kcu2.ordinal_position   = kcu.ordinal_position
+       WHERE kcu.table_schema = $2 AND kcu.table_name = $1
+       ORDER BY kcu.ordinal_position`, [tableName, schema]);
+        return result.rows.map((r) => ({
+            column: r.column_name,
+            foreignTable: r.foreign_table_schema === 'public'
+                ? r.foreign_table_name
+                : `${r.foreign_table_schema}.${r.foreign_table_name}`,
+            foreignColumn: r.foreign_column_name,
+        }));
+    }
+    async listEnums() {
+        const result = await this.client.query(`SELECT t.typname AS enum_name,
+              t.typnamespace::regnamespace::text AS schema_name,
+              json_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+       FROM pg_type t
+       JOIN pg_enum e ON e.enumtypid = t.oid
+       WHERE t.typtype = 'e'
+       GROUP BY t.typname, t.typnamespace
+       ORDER BY schema_name, enum_name`);
+        return result.rows.map((r) => ({
+            name: r.enum_name,
+            schema: r.schema_name,
+            values: r.values,
+        }));
+    }
     async close() {
         await this.client.end();
     }

package/dist/src/functions/db/sqlite/sqlite-introspector.d.ts

@@ -1,9 +1,11 @@
-import type { DbIntrospector, ColumnInfo } from '../db-introspector.js';
+import type { DbIntrospector, ColumnInfo, ForeignKeyInfo, EnumInfo } from '../db-introspector.js';
 import type { SyncSqliteDatabase } from './sqlite-runtime.js';
 export declare class SqliteIntrospector implements DbIntrospector {
     private readonly db;
     constructor(db: SyncSqliteDatabase);
     listTables(): Promise<string[]>;
     getColumns(table: string): Promise<ColumnInfo[]>;
+    getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
+    listEnums(): Promise<EnumInfo[]>;
     close(): Promise<void>;
 }

package/dist/src/functions/db/sqlite/sqlite-introspector.js

@@ -29,6 +29,20 @@ export class SqliteIntrospector {
             generated: c.hidden === 2 || c.hidden === 3,
         }));
     }
+    async getForeignKeys(table) {
+        const escaped = `"${table.replace(/"/g, '""')}"`;
+        const rows = this.db
+            .prepare(`PRAGMA foreign_key_list(${escaped})`)
+            .all();
+        return rows.map((r) => ({
+            column: r.from,
+            foreignTable: r.table,
+            foreignColumn: r.to,
+        }));
+    }
+    async listEnums() {
+        return [];
+    }
     async close() {
         this.db.close();
     }

package/dist/src/functions/db/sqlite/sqlite-runtime-node.js

@@ -1,9 +1,22 @@
 class NodeSqliteStatement {
     stmt;
     reader;
-    constructor(stmt) {
+    constructor(stmt, sql) {
         this.stmt = stmt;
-        this.reader = Boolean(stmt.reader);
+        // node:sqlite StatementSync does not have a .reader property
+        // (that's a better-sqlite3 API). Fall back to SQL inspection when absent.
+        if (stmt.reader !== undefined) {
+            this.reader = Boolean(stmt.reader);
+        }
+        else {
+            const upper = sql.trimStart().toUpperCase();
+            this.reader =
+                upper.startsWith('SELECT') ||
+                    upper.startsWith('WITH') ||
+                    upper.startsWith('PRAGMA') ||
+                    upper.startsWith('EXPLAIN') ||
+                    upper.startsWith('VALUES');
+        }
     }
     all(...parameters) {
         return this.stmt.all(...parameters);
@@ -31,7 +44,7 @@ class NodeSqliteDatabase {
         this.db.exec(sql);
     }
     prepare(sql) {
-        return new NodeSqliteStatement(this.db.prepare(sql));
+        return new NodeSqliteStatement(this.db.prepare(sql), sql);
     }
     close() {
         this.db.close();

package/dist/src/functions/wirings/auth/serialize-auth-gen.js

@@ -33,18 +33,20 @@ export const serializeAuthGen = (providers) => {
         const def = PROVIDER_REGISTRY[name];
         const schemaName = providerSchemaName(name);
         const fieldLines = Object.entries(def.fields).map(([field, zodExpr]) => `  ${field}: ${zodExpr},`);
-        lines.push(`const ${schemaName} = z.object({`);
+        lines.push(`export const ${schemaName} = z.object({`);
         lines.push(...fieldLines);
         lines.push(`})`);
         lines.push('');
     }
     // wireSecret for AUTH_SECRET
+    lines.push(`export const AuthSecretSchema = z.string()`);
+    lines.push('');
     lines.push(`wireSecret({`);
     lines.push(`  name: 'authSecret',`);
     lines.push(`  displayName: 'Auth Secret',`);
     lines.push(`  description: 'JWT signing secret for Auth.js sessions',`);
     lines.push(`  secretId: 'AUTH_SECRET',`);
-    lines.push(`  schema: z.string(),`);
+    lines.push(`  schema: AuthSecretSchema,`);
     lines.push(`})`);
     lines.push('');
     // wireSecret for each provider

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.28
+ * This file was generated by @pikku/cli@0.12.30
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.28",
+  "version": "0.12.30",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {
@@ -29,7 +29,7 @@
     "@pikku/core": "^0.12.27",
     "@pikku/deploy-cloudflare": "^0.12.3",
     "@pikku/fetch": "^0.12.2",
-    "@pikku/inspector": "^0.12.14",
+    "@pikku/inspector": "^0.12.15",
     "@pikku/kysely": "^0.12.14",
     "@pikku/kysely-node-sqlite": "^0.12.1",
     "@pikku/node-http-server": "^0.12.1",

package/skills/pikku-workflow/SKILL.md

@@ -71,6 +71,28 @@ await workflow.sleep('Wait 5 minutes', '5min')
 await workflow.suspend('Awaiting approval')
 ```
 
+### Choosing the right wrapper
+
+| Wrapper | When to use |
+|---|---|
+| `pikkuWorkflowFunc` | **Default.** Use for all new workflows. DSL mode — serialisable, replay-safe. |
+| `pikkuWorkflowComplexFunc` | **Only with explicit user approval.** For workflows with patterns the DSL extractor cannot handle (e.g. dynamic inline functions). Not a general escape hatch — restructure first. |
+| `pikkuWorkflowGraph` | **Only with explicit user approval.** For genuine DAGs where there is a cyclic dependency between nodes or a Node.js-only import DSL cannot express. |
+
+**Conditional results** — the correct DSL pattern when a step only runs under some condition:
+
+```typescript
+// ✅ Declare at top level, assign inside block
+let result: { id: string } | null = null
+if (input.createFoo) {
+  result = await workflow.do('Create foo', 'createFoo', { ... })
+}
+// Use result?.id downstream
+
+// ❌ Do NOT declare const inside a block — DSL forbids block-scoped declarations
+// ❌ Do NOT switch to pikkuWorkflowComplexFunc to avoid the restriction
+```
+
 ### `pikkuWorkflowGraph(config)` — DAG Workflows
 
 ```typescript