@pikku/cli 0.12.34 → 0.12.35

package/dist/src/functions/db/zod-codegen.js

@@ -1,11 +1,40 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+/**
+ * Canonical map of `format` tokens (authored in `db/annotations.ts`) to the zod
+ * expression they emit. These are all *string* refinements — they do not change
+ * the column's TypeScript type (it stays `string`), only the runtime validator.
+ * This is the single source of truth: `annotation-parser` imports it to validate
+ * authored values and `db-codegen` imports the key list to emit the `format`
+ * union in `ColumnEntry`. All confirmed present in zod 4.
+ */
+export const ZOD_FORMATS = {
+    email: 'z.email()',
+    url: 'z.url()',
+    emoji: 'z.emoji()',
+    e164: 'z.e164()',
+    jwt: 'z.jwt()',
+    cuid: 'z.cuid()',
+    cuid2: 'z.cuid2()',
+    ulid: 'z.ulid()',
+    nanoid: 'z.nanoid()',
+    base64: 'z.base64()',
+    base64url: 'z.base64url()',
+    ipv4: 'z.ipv4()',
+    ipv6: 'z.ipv6()',
+    cidrv4: 'z.cidrv4()',
+    cidrv6: 'z.cidrv6()',
+    isoDate: 'z.iso.date()',
+    isoTime: 'z.iso.time()',
+    isoDatetime: 'z.iso.datetime()',
+    isoDuration: 'z.iso.duration()',
+};
 const INTERFACE_RE = /export\s+interface\s+(\w+)\s*\{([^}]*)\}/g;
 const FIELD_RE = /^\s*(\w+)\s*:\s*(.+?)\s*$/gm;
 export function generateZodTypes(options) {
     const src = readFileSync(options.schemaFile, 'utf8');
     const tables = parseTables(src);
-    const body = emitZodModule(tables);
+    const body = emitZodModule(tables, options.formats ?? {});
     let existing = null;
     try {
         existing = readFileSync(options.outFile, 'utf8');
@@ -39,7 +68,7 @@ function parseTables(src) {
     }
     return tables;
 }
-function emitZodModule(tables) {
+function emitZodModule(tables, formats) {
     const lines = [];
     lines.push('// Generated by @pikku/cli — do not edit by hand.');
     lines.push('// Run `pikku db migrate` to refresh.');
@@ -49,8 +78,9 @@ function emitZodModule(tables) {
     for (const table of tables) {
         const rowFields = [];
         const insertFields = [];
+        const tableFormats = formats[table.name] ?? {};
         for (const field of table.fields) {
-            const { schema, generated } = zodForType(field.type);
+            const { schema, generated } = zodForType(field.type, tableFormats[field.name]);
             rowFields.push(`  ${field.name}: ${schema},`);
             insertFields.push(`  ${field.name}: ${schema}${generated ? '.optional()' : ''},`);
         }
@@ -83,7 +113,7 @@ function emitZodModule(tables) {
  * and the column is insert-optional when `Insert` admits `undefined` (Kysely's
  * encoding for default/auto/generated columns).
  */
-function zodForType(tsType) {
+function zodForType(tsType, format) {
     let inner = tsType.trim();
     let generated = false;
     // Peel a single `Generated<…>` wrapper. For public bool/date columns this
@@ -102,9 +132,9 @@ function zodForType(tsType) {
         if (unionIncludesUndefined(insertT)) {
             generated = true;
         }
-        return { schema: scalarSchema(selectT), generated };
+        return { schema: scalarSchema(selectT, format), generated };
     }
-    return { schema: scalarSchema(inner), generated };
+    return { schema: scalarSchema(inner, format), generated };
 }
 /**
  * Resolve a scalar/select type expression to a zod expression. Handles a
@@ -112,7 +142,7 @@ function zodForType(tsType) {
  * and the known scalar bases. Unknown bases fall back to `z.unknown()` so
  * generation stays total.
  */
-function scalarSchema(tsType) {
+function scalarSchema(tsType, format) {
     let inner = tsType.trim();
     // Defensive: a Select arg may itself be `Generated<…>` in older schemas.
     const generatedMatch = inner.match(/^Generated<(.+)>$/);
@@ -129,44 +159,126 @@ function scalarSchema(tsType) {
         inner = brandMatch[1].trim();
     }
     let schema;
-    switch (inner) {
-        case 'string':
-            schema = 'z.string()';
-            break;
-        case 'number':
-            schema = 'z.number()';
-            break;
-        case 'boolean':
-            schema = 'z.boolean()';
-            break;
-        case 'Date':
-            schema = 'z.date()';
-            break;
-        case 'unknown':
-            schema = 'z.unknown()';
-            break;
-        default:
-            if (inner.endsWith('[]')) {
-                schema = `z.array(${scalarSchema(inner.slice(0, -2).trim())})`;
-            }
-            else {
-                schema = 'z.unknown()';
+    // A `format` override (e.g. `email`, `url`) replaces the string base with a
+    // refined string validator. `db-codegen` only emits a format hint for columns
+    // whose select type is plain `string`, so this never collides with Date/enum.
+    if (format) {
+        schema = ZOD_FORMATS[format];
+    }
+    else {
+        // An enum column is emitted as a union of string literals, e.g.
+        // `'admin' | 'user'`. Detect it (after brand-unwrap + null-peel) and map to
+        // `z.enum([...])` (or `z.literal(...)` for a single value).
+        const literals = stringLiteralUnion(inner);
+        if (literals) {
+            schema =
+                literals.length === 1
+                    ? `z.literal('${literals[0]}')`
+                    : `z.enum([${literals.map((l) => `'${l}'`).join(', ')}])`;
+        }
+        else {
+            switch (inner) {
+                case 'string':
+                    schema = 'z.string()';
+                    break;
+                case 'number':
+                    schema = 'z.number()';
+                    break;
+                case 'boolean':
+                    schema = 'z.boolean()';
+                    break;
+                case 'Date':
+                    schema = 'z.date()';
+                    break;
+                case 'Uuid':
+                    schema = 'z.uuid()';
+                    break;
+                case 'unknown':
+                    schema = 'z.unknown()';
+                    break;
+                default:
+                    if (inner.endsWith('[]')) {
+                        schema = `z.array(${scalarSchema(inner.slice(0, -2).trim())})`;
+                    }
+                    else {
+                        schema = 'z.unknown()';
+                    }
+                    break;
             }
-            break;
+        }
     }
     if (nullable) {
         schema += '.nullable()';
     }
     return schema;
 }
-/** Split the generic argument list of `Foo<a, b, c>` on top-level commas. */
+/**
+ * If `s` is a union of single-quoted string literals (`'a' | 'b' | 'c'`),
+ * return the unescaped-as-written label list; otherwise null. Quote-aware so a
+ * label containing `|` does not split the union. Re-emitting wraps each captured
+ * group back in quotes, so escaping is preserved verbatim.
+ */
+function stringLiteralUnion(s) {
+    const parts = splitUnion(s);
+    const labels = [];
+    for (const part of parts) {
+        const match = part.trim().match(/^'((?:[^'\\]|\\.)*)'$/);
+        if (!match)
+            return null;
+        labels.push(match[1]);
+    }
+    return labels.length > 0 ? labels : null;
+}
+/** Split a union on top-level `|`, skipping `|` inside `'…'` strings or `<>`/`()`. */
+function splitUnion(s) {
+    const parts = [];
+    let depth = 0;
+    let inStr = false;
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const char = s[i];
+        if (inStr) {
+            if (char === '\\')
+                i++;
+            else if (char === "'")
+                inStr = false;
+            continue;
+        }
+        if (char === "'")
+            inStr = true;
+        else if (char === '<' || char === '(')
+            depth++;
+        else if (char === '>' || char === ')')
+            depth--;
+        else if (char === '|' && depth === 0) {
+            parts.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(s.slice(start));
+    return parts;
+}
+/**
+ * Split the generic argument list of `Foo<a, b, c>` on top-level commas.
+ * Quote-aware so a comma inside an enum label literal (`'a,b'`) does not split.
+ */
 function splitGenericArgs(args) {
     const parts = [];
     let depth = 0;
+    let inStr = false;
     let start = 0;
     for (let i = 0; i < args.length; i++) {
         const char = args[i];
-        if (char === '<')
+        if (inStr) {
+            if (char === '\\')
+                i++;
+            else if (char === "'")
+                inStr = false;
+            continue;
+        }
+        if (char === "'")
+            inStr = true;
+        else if (char === '<')
             depth++;
         else if (char === '>')
             depth--;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.12.34",
+  "version": "0.12.35",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "imports": {