cogsbox-shape 0.5.208 → 0.5.209

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;

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":

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", () => {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-shape",
-  "version": "0.5.208",
+  "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",