cogsbox-shape 0.5.207 → 0.5.209

package/README.md

@@ -307,6 +307,28 @@ schema({ ... })
 
 **Note**: `parsePatchForDb` uses the base schema (without refinement) since partial data may not satisfy cross-field rules.
 
+### Schemas vs Validators
+
+Each box entry exposes two sets of Zod schemas:
+
+- **`schemas`** — plain `ZodObject` shapes. Always composable with `.pick()`, `.omit()`, `.partial()`, etc. Use these for form field extraction, type inference, and partial validation.
+- **`validators`** — schema + refinements. These are `ZodEffects` when `.refine()` is used, otherwise the same `ZodObject`. Use these for full validation that enforces cross-field rules.
+
+```typescript
+const box = createSchemaBox({ events }, { events: {} });
+
+// Base schema — always a ZodObject, always composable
+box.events.schemas.client.pick({ startDate: true, endDate: true }); // works!
+
+// Validator — enforces refine rules
+box.events.validators.client.safeParse(data); // runs cross-field checks
+
+// Internal transforms use validators automatically
+box.events.transforms.parseForDb(data); // uses validator.server
+```
+
+Why the split? After `.refine()`, Zod wraps the schema in `ZodEffects`, which loses `.shape`, `.pick()`, `.omit()`, and `.partial()`. By keeping the base schema separate from refinements, you can always compose the shape while still enforcing cross-field rules when needed.
+
 ### Schema Object Structure
 
 The returned schema object has a clear separation of concerns:
@@ -314,16 +336,17 @@ The returned schema object has a clear separation of concerns:
 ```typescript
 const schema = createSchema(mySchema);
 
-schema.schemas; // { sql, client, clientChecked, server } — Zod schemas
+schema.schemas; // { sql, client, clientChecked, server } — ZodObject shapes (composable)
+schema.validators; // { sql, client, clientChecked, server } — with refinements enforced
 schema.transforms; // { toClient, toDb, parseForDb, parseFromDb } — transformations
 schema.defaults; // Default values for forms
-schema.generateDefaults; // Function to generate fresh client defaults (executes randomizers)
+schema.generateDefaults; // Function to generate fresh client defaults (executes randomizers)
 schema.pk; // Primary key field names
 schema.clientPk; // Client-side primary key field names
 schema.isClientRecord; // Function to check if a record is client-created
 schema.deriveDependencies; // Derive function dependencies ({ [field]: string[] })
 schema.refineInfo; // Refinement info ({ groups: RefineEntry[], fieldToGroup: Record<string, number[]> })
-```
+```
 
 ## Using Schemas
 
@@ -364,8 +387,11 @@ const { toClient, toDb, parseForDb, parseFromDb } = schema.transforms;
 const [data, setData] = useState(generateDefaults());
 // { id: "new_a1b2c3d4", name: "", email: "", isActive: true }
 
-// Validate explicitly
-const result = server.safeParse(data);
+// Validate explicitly (use validators for refinement enforcement)
+const result = schema.validators.server.safeParse(data);
+
+// Or use the base schema for shape operations
+const pickedSchema = schema.schemas.server.pick({ email: true, age: true });
 
 // Or handle validation & transformation in a single step!
 const safeDbRow = parseForDb(data);

package/cogsbox-shape-db/dist/table-db.js

@@ -35,8 +35,9 @@ export class TableDB {
                 }
             }
         }
-        const limit = opts?.limit ?? 100;
-        query = query.limit(limit);
+        if (opts?.limit !== undefined) {
+            query = query.limit(opts.limit);
+        }
         if (opts?.offset !== undefined) {
             query = query.offset(opts.offset);
         }

package/dist/generateSQL.js

@@ -27,6 +27,8 @@ function sqlType(dialect, fieldName, tableName, config) {
             switch (config.type) {
                 case "int":
                     return "INTEGER";
+                case "real":
+                    return "REAL";
                 case "boolean":
                     return "INTEGER";
                 case "varchar":
@@ -45,6 +47,8 @@ function sqlType(dialect, fieldName, tableName, config) {
             switch (config.type) {
                 case "int":
                     return "INTEGER";
+                case "real":
+                    return "REAL";
                 case "boolean":
                     return "BOOLEAN";
                 case "varchar":
@@ -70,6 +74,8 @@ function sqlType(dialect, fieldName, tableName, config) {
             switch (config.type) {
                 case "int":
                     return "INTEGER";
+                case "real":
+                    return "DOUBLE";
                 case "boolean":
                     return "TINYINT(1)";
                 case "varchar":

package/dist/schema.d.ts

@@ -14,6 +14,10 @@ type SQLTypeConfig = ({
     type: "int";
     nullable?: boolean;
     default?: number;
+} | {
+    type: "real";
+    nullable?: boolean;
+    default?: number;
 } | {
     type: "boolean";
     nullable?: boolean;
@@ -54,11 +58,11 @@ type BaseConfig = {
 };
 type SQLToZodType<T extends SQLTypeInput, TDefault extends boolean> = T["pk"] extends true ? TDefault extends true ? z.ZodString : z.ZodNumber : T["nullable"] extends true ? T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodNullable<z.ZodString> : T["type"] extends "enum" ? T extends {
     values: infer TValues extends readonly [string, ...string[]];
-} ? z.ZodNullable<z.ZodType<TValues[number]>> : never : T["type"] extends "int" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+} ? z.ZodNullable<z.ZodType<TValues[number]>> : never : T["type"] extends "int" | "real" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "boolean" ? z.ZodNullable<z.ZodNumber> : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
     default: "CURRENT_TIMESTAMP";
 } ? TDefault extends true ? never : z.ZodNullable<z.ZodDate> : z.ZodNullable<z.ZodDate> : never : T["type"] extends "varchar" | "char" | "text" | "longtext" ? z.ZodString : T["type"] extends "enum" ? T extends {
     values: infer TValues extends readonly [string, ...string[]];
-} ? z.ZodType<TValues[number]> : never : T["type"] extends "int" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodNumber : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
+} ? z.ZodType<TValues[number]> : never : T["type"] extends "int" | "real" ? z.ZodNumber : T["type"] extends "boolean" ? z.ZodNumber : T["type"] extends "date" | "datetime" | "timestamp" ? T extends {
     default: "CURRENT_TIMESTAMP";
 } ? TDefault extends true ? never : z.ZodDate : z.ZodDate : never;
 type ZodTypeFromPrimitive<T> = T extends string ? z.ZodString : T extends number ? z.ZodNumber : T extends boolean ? z.ZodBoolean : T extends Date ? z.ZodDate : z.ZodAny;
@@ -336,6 +340,12 @@ export declare function createSchema<T extends {
     clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientSchema">>>;
     clientCheckedSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodClientCheckedSchema">>>;
     serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<TActualSchema, "zodValidationSchema">>>;
+    validators: {
+        sql: z.ZodTypeAny;
+        client: z.ZodTypeAny;
+        clientChecked: z.ZodTypeAny;
+        server: z.ZodTypeAny;
+    };
     defaultValues: Prettify<DeriveDefaults<TActualSchema>>;
     stateType: Prettify<DeriveStateType<TActualSchema>>;
     generateDefaults: () => Prettify<DeriveDefaults<TActualSchema>>;
@@ -400,6 +410,12 @@ type ResolvedRegistryWithSchemas<S extends Record<string, SchemaWithPlaceholders
             clientSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientSchema">>>;
             clientCheckedSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodClientCheckedSchema">>>;
             serverSchema: z.ZodObject<Prettify<DeriveSchemaByKey<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>, "zodValidationSchema">>>;
+            validators: {
+                sql: z.ZodTypeAny;
+                client: z.ZodTypeAny;
+                clientChecked: z.ZodTypeAny;
+                server: z.ZodTypeAny;
+            };
             defaultValues: Prettify<DeriveDefaults<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
             stateType: Prettify<DeriveStateType<ResolveSchema<S[K], K extends keyof R ? (R[K] extends object ? R[K] : {}) : {}>>>;
         };
@@ -511,6 +527,12 @@ export type DeriveViewResult<TTableName extends keyof TRegistry, TSelection, TRe
         clientChecked: z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "clientCheckedSchema">>;
         server: z.ZodObject<_DeriveViewShape<TTableName, TSelection, TRegistry, "serverSchema">>;
     };
+    validators: {
+        sql: TRegistry[TTableName]["zodSchemas"]["validators"]["sql"];
+        client: TRegistry[TTableName]["zodSchemas"]["validators"]["client"];
+        clientChecked: TRegistry[TTableName]["zodSchemas"]["validators"]["clientChecked"];
+        server: TRegistry[TTableName]["zodSchemas"]["validators"]["server"];
+    };
     transforms: {
         toClient: TRegistry[TTableName]["transforms"]["toClient"];
         toDb: TRegistry[TTableName]["transforms"]["toDb"];
@@ -560,6 +582,12 @@ type RegistryShape = Record<string, {
         clientSchema: z.ZodObject<any>;
         clientCheckedSchema: z.ZodObject<any>;
         serverSchema: z.ZodObject<any>;
+        validators: {
+            sql: z.ZodTypeAny;
+            client: z.ZodTypeAny;
+            clientChecked: z.ZodTypeAny;
+            server: z.ZodTypeAny;
+        };
         defaultValues: any;
         stateType: any;
         deriveDependencies: Record<string, string[]>;
@@ -595,6 +623,12 @@ type CreateSchemaBoxReturn<S extends Record<string, SchemaWithPlaceholders>, R e
             clientChecked: Resolved[K]["zodSchemas"]["clientCheckedSchema"];
             server: Resolved[K]["zodSchemas"]["serverSchema"];
         };
+        validators: {
+            sql: Resolved[K]["zodSchemas"]["validators"]["sql"];
+            client: Resolved[K]["zodSchemas"]["validators"]["client"];
+            clientChecked: Resolved[K]["zodSchemas"]["validators"]["clientChecked"];
+            server: Resolved[K]["zodSchemas"]["validators"]["server"];
+        };
         transforms: {
             toClient: (dbData: z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>) => z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>;
             toDb: (clientData: z.infer<Resolved[K]["zodSchemas"]["clientSchema"]>) => z.infer<Resolved[K]["zodSchemas"]["sqlSchema"]>;

package/dist/schema.js

@@ -18,6 +18,9 @@ function createSqlBuilder(dialect, sqlConfig) {
                 case "int":
                     baseType = z.number();
                     break;
+                case "real":
+                    baseType = z.number();
+                    break;
                 case "boolean":
                     baseType = z.number();
                     break;
@@ -467,6 +470,8 @@ function inferDefaultFromZod(zodType, sqlConfig) {
                     return sqlTypeConfig.default ?? sqlTypeConfig.values[0];
                 case "int":
                     return 0;
+                case "real":
+                    return 0;
                 case "boolean":
                     return false;
                 case "date":
@@ -787,10 +792,16 @@ export function createSchema(schema, relations) {
         deriveDependencies,
         refineInfo: { groups: refineGroups ?? [], fieldToGroup },
         isClientRecord,
-        sqlSchema: refinedSqlSchema,
-        clientSchema: refinedClientSchema,
-        clientCheckedSchema: refinedClientCheckedSchema,
-        serverSchema: refinedValidationSchema,
+        sqlSchema: finalSqlSchema,
+        clientSchema: finalClientSchema,
+        clientCheckedSchema: finalClientCheckedSchema,
+        serverSchema: finalValidationSchema,
+        validators: {
+            sql: refinedSqlSchema,
+            client: refinedClientSchema,
+            clientChecked: refinedClientCheckedSchema,
+            server: refinedValidationSchema,
+        },
         defaultValues: defaultValues,
         stateType: {},
         generateDefaults,
@@ -1028,6 +1039,12 @@ export function createSchemaBox(schemas, resolutions) {
                 clientChecked: entry.zodSchemas.clientCheckedSchema,
                 server: entry.zodSchemas.serverSchema,
             },
+            validators: {
+                sql: entry.zodSchemas.validators.sql,
+                client: entry.zodSchemas.validators.client,
+                clientChecked: entry.zodSchemas.validators.clientChecked,
+                server: entry.zodSchemas.validators.server,
+            },
             transforms: {
                 toClient: entry.transforms.toClient,
                 toDb: entry.transforms.toDb,
@@ -1172,6 +1189,12 @@ export function createSchemaBox(schemas, resolutions) {
                         clientChecked: view.clientChecked,
                         server: view.server,
                     },
+                    validators: {
+                        sql: view.sql,
+                        client: view.client,
+                        clientChecked: view.clientChecked,
+                        server: view.server,
+                    },
                     transforms: {
                         toClient: viewToClient,
                         toDb: viewToDb,

package/dist/vitest/fullSchema.test.js

@@ -31,6 +31,17 @@ describe("Schema Builder Type Tests (with expect-type)", () => {
             expect(statusField.config.zodSqlSchema.parse("draft")).toBe("draft");
             expect(() => statusField.config.zodSqlSchema.parse("deleted")).toThrow();
         });
+        it("should correctly type a real (float) field", () => {
+            const tempField = s.sqlite({ type: "real" });
+            expectTypeOf(tempField.config.zodSqlSchema).toEqualTypeOf();
+            expect(tempField.config.zodSqlSchema.parse(3.14)).toBe(3.14);
+        });
+        it("should correctly type a nullable real field", () => {
+            const nullableReal = s.sqlite({ type: "real", nullable: true });
+            expectTypeOf(nullableReal.config.zodClientCheckedSchema).toEqualTypeOf();
+            expect(nullableReal.config.zodSqlSchema.parse(null)).toBeNull();
+            expect(nullableReal.config.zodSqlSchema.parse(2.5)).toBe(2.5);
+        });
     });
     describe("Chainable Methods", () => {
         it("should create a union type when .client provides a different type", () => {
@@ -368,7 +379,7 @@ describe("client vs clientChecked schema divergence after .clientCheck()", () =>
             id: 1, password: "abc", confirmPassword: "def",
         });
         expect(clientResult.success).toBe(true);
-        const clientCheckedResult = box.forms.schemas.clientChecked.safeParse({
+        const clientCheckedResult = box.forms.validators.clientChecked.safeParse({
             id: 1, password: "abc", confirmPassword: "def",
         });
         expect(clientCheckedResult.success).toBe(false);
@@ -1204,7 +1215,7 @@ describe("refine", () => {
             }),
         ]);
         const box = createSchemaBox({ forms }, { forms: {} });
-        const result = box.forms.schemas.client.safeParse({
+        const result = box.forms.validators.client.safeParse({
             id: 1,
             password: "secret",
             confirmPassword: "different",
@@ -1213,7 +1224,7 @@ describe("refine", () => {
         if (!result.success) {
             expect(result.error.issues[0].message).toBe("Passwords must match");
         }
-        const validResult = box.forms.schemas.client.safeParse({
+        const validResult = box.forms.validators.client.safeParse({
             id: 1,
             password: "secret",
             confirmPassword: "secret",

package/dist/vitest/generateSQL.test.js

@@ -67,4 +67,32 @@ describe("generateSQL dialect columns", () => {
         });
         await expect(withOutputFile((path) => generateSQL({ posts }, path))).rejects.toThrow(/Mixed SQL dialects/);
     });
+    it("generates REAL column for SQLite real type", async () => {
+        const measurements = schema({
+            _tableName: "measurements",
+            id: s.sqlite({ type: "int", pk: true }),
+            temperature: s.sqlite({ type: "real" }),
+            humidity: s.sqlite({ type: "real", nullable: true }),
+        });
+        const sql = await withOutputFile((path) => generateSQL({ measurements }, path));
+        expect(sql).toContain("id INTEGER PRIMARY KEY");
+        expect(sql).toContain("temperature REAL NOT NULL");
+        expect(sql).toContain("humidity REAL");
+    });
+    it("generates REAL for Postgres and DOUBLE for MySQL real type", async () => {
+        const pgData = schema({
+            _tableName: "readings",
+            id: s.postgres({ type: "int", pk: true }),
+            value: s.postgres({ type: "real" }),
+        });
+        const pgSql = await withOutputFile((path) => generateSQL({ pgData }, path));
+        expect(pgSql).toContain("value REAL NOT NULL");
+        const myData = schema({
+            _tableName: "readings",
+            id: s.mysql({ type: "int", pk: true }),
+            value: s.mysql({ type: "real" }),
+        });
+        const mySql = await withOutputFile((path) => generateSQL({ myData }, path));
+        expect(mySql).toContain("value DOUBLE NOT NULL");
+    });
 });

package/dist/vitest/refineRuntime.test.js

@@ -32,16 +32,16 @@ describe("refine runtime behavior", () => {
         ]);
         return createSchemaBox({ rules }, { rules: {} });
     }
-    it("schemas.client catches client refine", () => {
+    it("validators.client catches client refine", () => {
         const box = makeRefinedBox();
-        const good = box.rules.schemas.client.safeParse({
+        const good = box.rules.validators.client.safeParse({
             id: 1,
             min: 1,
             max: 10,
             label: "x",
         });
         expect(good.success).toBe(true);
-        const bad = box.rules.schemas.client.safeParse({
+        const bad = box.rules.validators.client.safeParse({
             id: 1,
             min: 10,
             max: 1,
@@ -52,9 +52,9 @@ describe("refine runtime behavior", () => {
             expect(bad.error.issues[0].message).toBe("Max must be > min");
         }
     });
-    it("schemas.clientChecked catches client refine", () => {
+    it("validators.clientChecked catches client refine", () => {
         const box = makeRefinedBox();
-        const bad = box.rules.schemas.clientChecked.safeParse({
+        const bad = box.rules.validators.clientChecked.safeParse({
             id: 1,
             min: 10,
             max: 1,
@@ -65,9 +65,9 @@ describe("refine runtime behavior", () => {
             expect(bad.error.issues[0].message).toBe("Max must be > min");
         }
     });
-    it("schemas.server catches server refine", () => {
+    it("validators.server catches server refine", () => {
         const box = makeRefinedBox();
-        const bad = box.rules.schemas.server.safeParse({
+        const bad = box.rules.validators.server.safeParse({
             id: 1,
             min: 1,
             max: 10,
@@ -78,9 +78,9 @@ describe("refine runtime behavior", () => {
             expect(bad.error.issues[0].message).toBe("Label required");
         }
     });
-    it("schemas.sql catches server refine", () => {
+    it("validators.sql catches server refine", () => {
         const box = makeRefinedBox();
-        const bad = box.rules.schemas.sql.safeParse({
+        const bad = box.rules.validators.sql.safeParse({
             id: 1,
             min: 1,
             max: 10,
@@ -122,36 +122,18 @@ describe("refine runtime behavior", () => {
         });
         expect(good.success).toBe(true);
     });
-    it("view keeps leaf refines and prefixes issue paths", () => {
-        const rules = schema({
-            _tableName: "rules",
-            id: s.sqlite({ type: "int", pk: true }),
-            min: s
-                .sqlite({ type: "int", field: "minField" })
-                .client({ value: 0 }),
-            max: s.sqlite({ type: "int" }).client({ value: 0 }),
-        }).refine((r) => [
-            r("clientCheck", (row) => row.min >= row.max
-                ? { path: ["max"], message: "Max must be > min" }
-                : undefined, ["min", "max"]),
-        ]);
-        const journal = schema({
-            _tableName: "journal",
-            id: s.sqlite({ type: "int", pk: true }),
-            rules: s.hasOne(true),
-        });
-        const box = createSchemaBox({ rules, journal }, {
-            journal: { rules: { fromKey: "id", toKey: rules.id } },
-        });
-        const view = box.journal.createView({ rules: true });
-        const bad = view.schemas.clientChecked.safeParse({
+    it("validators enforce refine on direct table schemas", () => {
+        const box = makeRefinedBox();
+        const bad = box.rules.validators.clientChecked.safeParse({
             id: 1,
-            rules: { id: 1, min: 10, max: 1 },
+            min: 10,
+            max: 1,
+            label: "x",
         });
         expect(bad.success).toBe(false);
         if (!bad.success) {
             expect(bad.error.issues[0]).toMatchObject({
-                path: ["rules", "max"],
+                path: ["max"],
                 message: "Max must be > min",
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.207",
+  "version": "0.5.209",
   "description": "A TypeScript library for creating type-safe database schemas with Zod validation, SQL type definitions, and automatic client/server transformations. Unifies client, server, and database types through a single schema definition, with built-in support for relationships and serialization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",