@skyf0xx/hedgehog 4.3.1 → 4.3.4

package/src/golden-cores/full-stack-app/apps/web/package.json

@@ -21,6 +21,18 @@
     "prettier-plugin-tailwindcss": "^0.7.4"
   },
   "nx": {
+    "targets": {
+      "generate-module-routes": {
+        "executor": "nx:run-commands",
+        "cache": true,
+        "inputs": ["{projectRoot}/src/app/*/page.tsx"],
+        "outputs": ["{projectRoot}/src/app/module-routes.ts"],
+        "options": {
+          "command": "node tools/generate-module-routes.cjs",
+          "cwd": "{workspaceRoot}"
+        }
+      }
+    },
     "tags": ["scope:web"]
   }
 }

package/src/golden-cores/full-stack-app/apps/web/src/app/module-routes.ts

@@ -0,0 +1,13 @@
+// GENERATED FILE — do not hand-edit. Regenerated by
+// tools/generate-module-routes.cjs (the generate-module-routes Nx
+// target, which build, typecheck and test depend on) from every
+// apps/web/src/app/*/page.tsx file on disk. A module's screen layer
+// only ever creates its own page.tsx inside its own directory —
+// never edits this file or the root page.
+
+export interface ModuleRoute {
+  href: string;
+  label: string;
+}
+
+export const moduleRoutes: ModuleRoute[] = [];

package/src/golden-cores/full-stack-app/apps/web/src/app/page.tsx

@@ -1,6 +1,13 @@
+import Link from 'next/link';
 import { Button } from '@/components/ui/button';
 import { ThemeToggle } from '@/components/theme-toggle';
+import { moduleRoutes } from './module-routes';
 
+// The index of everything built so far. `moduleRoutes` is generated from
+// the route directories on disk (tools/generate-module-routes.cjs), so a
+// module's screen layer only writes its own apps/web/src/app/<module>/
+// and this page picks it up — no task ever edits this file, which is what
+// keeps it outside every module-scoped layer's ALLOWED SCOPE.
 export default function Index() {
   return (
     <div className="flex min-h-screen flex-col items-center justify-center gap-6 p-8">
@@ -8,7 +15,20 @@ export default function Index() {
         <h1 className="text-2xl font-semibold">Hedgehog</h1>
         <ThemeToggle />
       </div>
-      <Button>Get started</Button>
+
+      {moduleRoutes.length === 0 ? (
+        <p className="text-muted-foreground max-w-prose text-center text-sm">
+          No modules yet. Each one you build gets a route here.
+        </p>
+      ) : (
+        <nav className="flex flex-wrap items-center justify-center gap-3">
+          {moduleRoutes.map((route) => (
+            <Button key={route.href} asChild variant="outline">
+              <Link href={route.href}>{route.label}</Link>
+            </Button>
+          ))}
+        </nav>
+      )}
     </div>
   );
 }

package/src/golden-cores/full-stack-app/nx.json

@@ -2,14 +2,18 @@
   "$schema": "./node_modules/nx/schemas/nx-schema.json",
   "targetDefaults": {
     "build": {
-      "cache": true
+      "cache": true,
+      "dependsOn": ["generate-module-routes"]
+    },
+    "dev": {
+      "dependsOn": ["generate-module-routes"]
     },
     "test": {
       "cache": true,
-      "dependsOn": ["^build", "generate-feature-modules"]
+      "dependsOn": ["^build", "generate-feature-modules", "generate-module-routes"]
     },
     "typecheck": {
-      "dependsOn": ["generate-feature-modules"]
+      "dependsOn": ["generate-feature-modules", "generate-module-routes"]
     },
     "lint": {
       "cache": true

package/src/golden-cores/full-stack-app/packages/db/src/lib/db.ts

@@ -19,7 +19,21 @@ let client: NodePgDatabase | undefined;
 export function getPool(): Pool {
   if (!pool) {
     const env = loadEnv();
-    pool = new Pool({ connectionString: env.DATABASE_URL });
+    pool = new Pool({
+      connectionString: env.DATABASE_URL,
+      // A wedged connection surfaces as a query error rather than a hang.
+      connectionTimeoutMillis: 10_000,
+      idleTimeoutMillis: 30_000,
+    });
+    // `pg` emits 'error' on the pool when an *idle* client's connection dies
+    // (Postgres restart, failover, laptop sleep). Node terminates the process
+    // on an unhandled 'error' event, so without this listener a routine
+    // database blip crashes the API. `pg` has already discarded the bad
+    // client by the time this fires: the next query opens a fresh connection,
+    // so logging and swallowing is the recovery.
+    pool.on('error', (err) => {
+      console.error('idle postgres client error', err);
+    });
   }
   return pool;
 }

package/src/golden-cores/full-stack-app/tools/generate-module-routes.cjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * Regenerates apps/web/src/app/module-routes.ts — the list of every
+ * domain module's route for the root page to link.
+ *
+ * Written as CommonJS (`.cjs`) for the same reason as its sibling
+ * generate-feature-modules.cjs: root `package.json` sets `"type":
+ * "module"`, so a plain `.js` file here would be parsed as ESM.
+ *
+ * Why generated rather than hand-edited: the screen layer's scope is
+ * `apps/web/src/app/{module}/**` (core.yaml) — module-disjoint by
+ * construction, and `validateCore` requires that `{module}` on a
+ * module-axis core, so `apps/web/src/app/page.tsx` one level up is
+ * outside every layer's scope. Without this the root page can never
+ * learn about the modules built beneath it: a finished build ships a
+ * landing page with no route into the app it just built. This is the
+ * same shape as the API's feature-modules barrel, and gets the same
+ * answer — a shared file no module-scoped task can safely touch is
+ * generated, never hand-edited.
+ *
+ * Convention: any apps/web/src/app/<segment>/page.tsx (route directories
+ * only, one level deep — not the root page.tsx itself) is a module
+ * route. Next.js route groups and private directories are skipped:
+ * `(group)` does not appear in the URL, and `_private`/`.`-prefixed
+ * directories are not routes at all.
+ *
+ * Run via the `generate-module-routes` Nx target, which build, typecheck
+ * and test depend on (nx.json targetDefaults) — never run by hand as
+ * part of normal development.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const APP_DIR = path.join(__dirname, '..', 'apps', 'web', 'src', 'app');
+const OUTPUT_FILE = path.join(APP_DIR, 'module-routes.ts');
+const HEADER =
+  '// GENERATED FILE — do not hand-edit. Regenerated by\n' +
+  '// tools/generate-module-routes.cjs (the generate-module-routes Nx\n' +
+  '// target, which build, typecheck and test depend on) from every\n' +
+  "// apps/web/src/app/*/page.tsx file on disk. A module's screen layer\n" +
+  '// only ever creates its own page.tsx inside its own directory —\n' +
+  '// never edits this file or the root page.\n';
+
+function findRouteDirs() {
+  if (!fs.existsSync(APP_DIR)) return [];
+  const entries = fs.readdirSync(APP_DIR, { withFileTypes: true });
+  const routes = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    // `(group)` is a route group — it organises files without adding a
+    // URL segment, so it is not a route. `_x` and `.x` are conventions
+    // for "not a route" too.
+    if (/^[(_.]/.test(entry.name)) continue;
+    if (fs.existsSync(path.join(APP_DIR, entry.name, 'page.tsx'))) {
+      routes.push(entry.name);
+    }
+  }
+  return routes.sort();
+}
+
+/** "order-items" -> "Order items" — a label, not a class name. */
+function labelFor(segment) {
+  const spaced = segment.replace(/-/g, ' ');
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+function main() {
+  const routes = findRouteDirs();
+
+  const entries = routes
+    .map((segment) => `  { href: '/${segment}', label: '${labelFor(segment)}' },`)
+    .join('\n');
+
+  const body =
+    `export interface ModuleRoute {\n` +
+    `  href: string;\n` +
+    `  label: string;\n` +
+    `}\n\n` +
+    (routes.length > 0
+      ? `export const moduleRoutes: ModuleRoute[] = [\n${entries}\n];\n`
+      : `export const moduleRoutes: ModuleRoute[] = [];\n`);
+
+  fs.writeFileSync(OUTPUT_FILE, HEADER + '\n' + body);
+  console.log(
+    `Generated ${path.relative(process.cwd(), OUTPUT_FILE)} with ${routes.length} module route(s).`,
+  );
+}
+
+main();

package/src/golden-cores/full-stack-app/tools/generators/contract/generator.ts

@@ -6,6 +6,7 @@ import { moduleNames, ModuleNames } from '../naming';
 interface ContractGeneratorOptions {
   module: string;
   fields: string;
+  toggleField?: string;
 }
 
 const PACKAGE_ROOT = 'packages/contracts';
@@ -32,9 +33,15 @@ export default async function contractGenerator(
   const dir = `${PACKAGE_ROOT}/src/${names.module}`;
   tree.write(`${dir}/${names.module}.schema.ts`, entitySchemaFile(names, fields));
   tree.write(`${dir}/${names.module}.errors.ts`, errorSchemaFile(names));
-  tree.write(`${dir}/${names.module}.contract.ts`, contractFile(names));
+  tree.write(
+    `${dir}/${names.module}.contract.ts`,
+    contractFile(names, options.toggleField),
+  );
   tree.write(`${dir}/index.ts`, barrelFile(names));
-  tree.write(`${dir}/${names.module}.spec.ts`, specFile(names, fields));
+  tree.write(
+    `${dir}/${names.module}.spec.ts`,
+    specFile(names, fields, options.toggleField),
+  );
 
   appendBarrelExport(tree, `${PACKAGE_ROOT}/src/index.ts`, `./${names.module}/index`);
 
@@ -115,7 +122,34 @@ export type ${names.entityPascal}BadRequest = z.infer<typeof ${names.entityCamel
 `;
 }
 
-function contractFile(names: ModuleNames): string {
+/**
+ * The toggle route carries `c.noBody()` deliberately: the new value is
+ * derived from stored state on the server, inside the service's existing
+ * transaction. A route that took the current value as a body would be a
+ * read-modify-write with the read served from the client's cache, so two
+ * toggles racing from one stale row would both write the same value and
+ * lose a flip.
+ *
+ * `@ts-rest/core` generates no `body` parameter for a `c.noBody()` route,
+ * so the call site is `client.toggle({ params: { id } })` — passing
+ * `body: undefined` is a compile error.
+ */
+function toggleRoute(names: ModuleNames): string {
+  return `    toggle: {
+      method: 'POST',
+      path: '/${names.module}/:id/toggle',
+      pathParams: z.object({ id: z.uuid() }),
+      body: c.noBody(),
+      responses: {
+        200: ${names.entityCamel}Schema,
+        404: ${names.entityCamel}NotFoundSchema,
+      },
+      summary: 'Flip a ${names.entityCamel} from its stored state',
+    },
+`;
+}
+
+function contractFile(names: ModuleNames, toggleField?: string): string {
   return `import { initContract } from '@ts-rest/core';
 import { z } from 'zod';
 import {
@@ -182,7 +216,7 @@ export const ${names.camel}Contract = c.router(
       },
       summary: 'Delete a ${names.entityCamel}',
     },
-  },
+${toggleField ? toggleRoute(names) : ''}  },
   {
     // apps/api sets /api as a global prefix at runtime (apps/api/src/main.ts),
     // so the paths above stay prefix-free and the client adds the base URL.
@@ -199,7 +233,11 @@ export * from './${names.module}.schema';
 `;
 }
 
-function specFile(names: ModuleNames, fields: Field[]): string {
+function specFile(
+  names: ModuleNames,
+  fields: Field[],
+  toggleField?: string,
+): string {
   const dateField = fields.find(isDateField);
   const requiredField = fields.find((field) => !field.nullable);
 
@@ -221,7 +259,22 @@ describe('${names.camel} contract', () => {
     expect(${names.camel}Contract.update.method).toBe('PATCH');
     expect(${names.camel}Contract.remove.method).toBe('DELETE');
   });
-
+${
+  toggleField
+    ? `
+  it('takes no body on toggle, so a stale client value cannot overwrite state', () => {
+    expect(${names.camel}Contract.toggle.method).toBe('POST');
+    expect(${names.camel}Contract.toggle.path).toBe('/${names.module}/:id/toggle');
+    // c.noBody() is a marker symbol at runtime; what it buys is a client
+    // call signature with no body parameter at all, so the new ${toggleField}
+    // can only be derived server-side.
+    expect(String(${names.camel}Contract.toggle.body)).toBe(
+      'Symbol(ContractNoBody)',
+    );
+  });
+`
+    : ''
+}
   it('accepts a server-side row, where every timestamp is a Date', () => {
     expect(${names.entityCamel}Schema.parse(sample)).toBeDefined();
   });

package/src/golden-cores/full-stack-app/tools/generators/contract/schema.json

@@ -12,8 +12,12 @@
     },
     "fields": {
       "type": "string",
-      "description": "The same name:type list the schema layer was generated with; a trailing ? marks the field nullable.",
+      "description": "The same name:type list the schema layer was generated with; a trailing ? marks the field nullable, and string takes an optional length (title:string(500)).",
       "x-prompt": "Fields (name:type, comma-separated)?"
+    },
+    "toggleField": {
+      "type": "string",
+      "description": "A boolean field from the schema layer to expose as a server-side toggle. Pass the same value to the schema, contract, service, controller, and hook layers. Omit when the module has none."
     }
   },
   "required": ["module", "fields"]

package/src/golden-cores/full-stack-app/tools/generators/controller/generator.ts

@@ -6,6 +6,7 @@ import { moduleNames, ModuleNames } from '../naming';
 interface ControllerGeneratorOptions {
   module: string;
   fields: string;
+  toggleField?: string;
 }
 
 const API_ROOT = 'apps/api';
@@ -43,9 +44,15 @@ export default async function controllerGenerator_(
   // full path, so leaving it would prefix each route twice.
   stripControllerBasePath(tree, `${stem}.controller.ts`);
 
-  tree.write(`${stem}.controller.ts`, controllerFile(names, fields));
+  tree.write(
+    `${stem}.controller.ts`,
+    controllerFile(names, fields, options.toggleField),
+  );
   tree.write(`${stem}.module.ts`, moduleFile(names));
-  tree.write(`${stem}.controller.spec.ts`, controllerSpecFile(names));
+  tree.write(
+    `${stem}.controller.spec.ts`,
+    controllerSpecFile(names, options.toggleField),
+  );
 
   addApiDependencies(tree, names);
 
@@ -62,7 +69,11 @@ function stripControllerBasePath(tree: Tree, path: string) {
   tree.write(path, source.replace(/@Controller\((['"]).*?\1\)/, '@Controller()'));
 }
 
-function controllerFile(names: ModuleNames, fields: Field[]): string {
+function controllerFile(
+  names: ModuleNames,
+  fields: Field[],
+  toggleField?: string,
+): string {
   const { entityPascal, entityCamel, camel, module } = names;
   const dateFields = fields.filter(isDateField);
   const wireShape = dateFields.length
@@ -129,7 +140,25 @@ export class ${names.pascal}Controller {
         } catch (error) {
           return notFoundOr(error, params.id);
         }
-      },
+      },${
+        toggleField
+          ? `
+
+      // The id is the whole request: the service reads the current value
+      // and flips it inside its own transaction, so there is no client
+      // value here that could be stale.
+      toggle: async ({ params }) => {
+        try {
+          return {
+            status: 200 as const,
+            body: await this.${entityCamel}s.toggle${entityPascal}(params.id),
+          };
+        } catch (error) {
+          return notFoundOr(error, params.id);
+        }
+      },`
+          : ''
+      }
     });
   }
 }
@@ -170,10 +199,14 @@ function fromWire<T extends ${wireShape}>(body: T) {
   };
 }
 
-function toDate(value: Date | string | null | undefined) {
+${
+  dateFields.length
+    ? `function toDate(value: Date | string | null | undefined) {
   return typeof value === 'string' ? new Date(value) : value;
 }
-`;
+`
+    : ''
+}`;
 }
 
 function moduleFile(names: ModuleNames): string {
@@ -217,7 +250,7 @@ export class ${pascal}Module {}
 `;
 }
 
-function controllerSpecFile(names: ModuleNames): string {
+function controllerSpecFile(names: ModuleNames, toggleField?: string): string {
   const { entityPascal, pascal, module } = names;
 
   return `import { Test } from '@nestjs/testing';
@@ -285,7 +318,41 @@ describe('${pascal}Controller', () => {
       handler.get({ params: { id: 'any' } } as never),
     ).rejects.toBe(boom);
   });
-});
+${
+  toggleField
+    ? `
+  it('passes only the id to the service, so no client value reaches the write', async () => {
+    const toggle${entityPascal} = vi.fn(async () => ({ id: 'one' }) as never);
+    const controller = await controllerWith({ toggle${entityPascal} });
+
+    const handler = await controller.handler();
+    const response = await handler.toggle({
+      params: { id: 'one' },
+    } as never);
+
+    expect(toggle${entityPascal}).toHaveBeenCalledWith('one');
+    expect(response).toMatchObject({ status: 200 });
+  });
+
+  it('maps a not-found on toggle to 404', async () => {
+    const controller = await controllerWith({
+      toggle${entityPascal}: vi.fn(async () => {
+        throw Object.assign(new Error('absent'), {
+          name: '${entityPascal}NotFoundError',
+        });
+      }),
+    });
+
+    const handler = await controller.handler();
+    const response = await handler.toggle({
+      params: { id: 'missing' },
+    } as never);
+
+    expect(response).toMatchObject({ status: 404 });
+  });
+`
+    : ''
+}});
 `;
 }
 

package/src/golden-cores/full-stack-app/tools/generators/controller/schema.json

@@ -12,8 +12,12 @@
     },
     "fields": {
       "type": "string",
-      "description": "The same name:type list the schema layer was generated with; a trailing ? marks the field nullable.",
+      "description": "The same name:type list the schema layer was generated with; a trailing ? marks the field nullable, and string takes an optional length (title:string(500)).",
       "x-prompt": "Fields (name:type, comma-separated)?"
+    },
+    "toggleField": {
+      "type": "string",
+      "description": "A boolean field from the schema layer to expose as a server-side toggle. Pass the same value to the schema, contract, service, controller, and hook layers. Omit when the module has none."
     }
   },
   "required": ["module", "fields"]

package/src/golden-cores/full-stack-app/tools/generators/fields.ts

@@ -7,6 +7,13 @@
  * Wire format (the `--fields` option): a comma-separated list of
  * `name:type` pairs, with a trailing `?` on the type marking the column
  * nullable — `title:string,done:boolean,dueDate:timestamp?`.
+ *
+ * A `string` takes an optional length in parentheses —
+ * `title:string(500)`, or `title:string(500)?` when it is also nullable.
+ * The value threads to both the Drizzle `varchar` and the Zod `.max()`,
+ * so the two bounds are the same number by construction: a Zod bound that
+ * outran its column would let an over-long value past validation and fail
+ * at the driver as a 500 instead of a 400.
  */
 
 export type FieldType =
@@ -20,8 +27,13 @@ export interface Field {
   name: string;
   type: FieldType;
   nullable: boolean;
+  /** Max characters for a `string`; undefined on every other type. */
+  length?: number;
 }
 
+/** The `varchar` bound a `string` gets when the field list names none. */
+export const DEFAULT_STRING_LENGTH = 255;
+
 const FIELD_TYPES: readonly FieldType[] = [
   'string',
   'text',
@@ -43,18 +55,35 @@ export function parseFields(raw: string): Field[] {
         );
       }
       const nullable = rawType.endsWith('?');
-      const type = (nullable ? rawType.slice(0, -1) : rawType) as FieldType;
+      const bare = nullable ? rawType.slice(0, -1) : rawType;
+
+      const sized = /^(\w+)\((\d+)\)$/.exec(bare);
+      const type = (sized ? sized[1] : bare) as FieldType;
+      const length = sized ? Number(sized[2]) : undefined;
+
       if (!FIELD_TYPES.includes(type)) {
         throw new Error(
           `Field "${entry}" has unknown type "${type}". Known types: ${FIELD_TYPES.join(', ')}.`,
         );
       }
+      // A length on anything but `string` has no column to bind to, so it
+      // would be silently dropped — the exact failure mode the syntax
+      // exists to remove. `text` is unbounded by design: cap it and you
+      // want a `string`.
+      if (length !== undefined && type !== 'string') {
+        throw new Error(
+          `Field "${entry}" puts a length on "${type}", which has no length. Only string does (title:string(500)).`,
+        );
+      }
+      if (length !== undefined && length < 1) {
+        throw new Error(`Field "${entry}" has length ${length}; it must be at least 1.`);
+      }
       if (RESERVED_FIELD_NAMES.includes(name)) {
         throw new Error(
           `Field "${name}" collides with a column every table already carries (${RESERVED_FIELD_NAMES.join(', ')}).`,
         );
       }
-      return { name, type, nullable };
+      return { name, type, nullable, length };
     });
 
   if (fields.length === 0) {
@@ -88,10 +117,15 @@ const DRIZZLE_IMPORT: Record<FieldType, string> = {
   timestamp: 'timestamp',
 };
 
+/** The character bound for a `string`, named or defaulted. */
+export function stringLength(field: Field): number {
+  return field.length ?? DEFAULT_STRING_LENGTH;
+}
+
 export function drizzleColumn(field: Field): string {
   const column = `'${columnName(field.name)}'`;
   const base: Record<FieldType, string> = {
-    string: `varchar(${column}, { length: 255 })`,
+    string: `varchar(${column}, { length: ${stringLength(field)} })`,
     text: `text(${column})`,
     boolean: `boolean(${column})`,
     integer: `integer(${column})`,
@@ -116,7 +150,7 @@ export function isDateField(field: Field): boolean {
 /** The Zod schema for a field as it appears in a hand-written override. */
 export function zodSchema(field: Field): string {
   const base: Record<FieldType, string> = {
-    string: 'z.string().min(1).max(255)',
+    string: `z.string().min(1).max(${stringLength(field)})`,
     text: 'z.string()',
     boolean: 'z.boolean()',
     integer: 'z.number().int()',

package/src/golden-cores/full-stack-app/tools/generators/hook/generator.ts

@@ -196,19 +196,29 @@ export function useRemove${entityPascal}() {
     toggleField
       ? `
 
+/**
+ * Sends the id and nothing else. The server reads the current
+ * ${toggleField} and flips it inside one transaction, so a stale row in
+ * this cache cannot overwrite a newer state — which is what computing
+ * the new value here from a cached row would do, losing one of any two
+ * flips that raced.
+ */
 export function useToggle${entityPascal}() {
-  const update = useUpdate${entityPascal}();
-
-  return {
-    ...update,
-    mutate: (variables: { id: string; ${toggleField}: boolean }) =>
-      update.mutate({ id: variables.id, ${toggleField}: !variables.${toggleField} }),
-    mutateAsync: (variables: { id: string; ${toggleField}: boolean }) =>
-      update.mutateAsync({
-        id: variables.id,
-        ${toggleField}: !variables.${toggleField},
-      }),
-  };
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string) => {
+      const response = await client.toggle({ params: { id } });
+      if (response.status !== 200) {
+        throw new Error(\`Failed to toggle ${names.entityCamel} \${id}.\`);
+      }
+      return response.body;
+    },
+    onSuccess: (_result, id) => {
+      queryClient.invalidateQueries({ queryKey: ${camel}Keys.lists() });
+      queryClient.invalidateQueries({ queryKey: ${camel}Keys.detail(id) });
+    },
+  });
 }`
       : ''
   }
@@ -266,6 +276,13 @@ describe('${camel} hooks', () => {
     const { useToggle${entityPascal} } = await import('./use-${names.module}');
 
     expect(useToggle${entityPascal}).toBeTypeOf('function');
+  });
+
+  it('routes the toggle at a server endpoint that takes no body', async () => {
+    const { ${camel}Contract } = await import('contracts');
+
+    expect(${camel}Contract.toggle.method).toBe('POST');
+    expect(String(${camel}Contract.toggle.body)).toBe('Symbol(ContractNoBody)');
   });`
       : ''
   }

package/src/golden-cores/full-stack-app/tools/generators/hook/schema.json

@@ -12,7 +12,7 @@
     },
     "toggleField": {
       "type": "string",
-      "description": "A boolean field from the schema layer to expose as a dedicated toggle mutation. Omit when the module has none."
+      "description": "A boolean field from the schema layer to expose as a server-side toggle. Pass the same value to the schema, contract, service, controller, and hook layers. Omit when the module has none."
     }
   },
   "required": ["module"]

package/src/golden-cores/full-stack-app/tools/generators/schema/schema.json

@@ -12,7 +12,7 @@
     },
     "fields": {
       "type": "string",
-      "description": "Comma-separated name:type pairs; a trailing ? marks the column nullable. Types: string, text, boolean, integer, timestamp. Example: title:string,done:boolean,dueDate:timestamp?",
+      "description": "Comma-separated name:type pairs; a trailing ? marks the column nullable, and string takes an optional length in parentheses (default 255). Types: string, text, boolean, integer, timestamp. Example: title:string(500),done:boolean,dueDate:timestamp?",
       "x-prompt": "Fields (name:type, comma-separated)?"
     }
   },