Merge pull request #27 from BriefHQ/data-type-narrow

fix: narrowed supported data types

Author: 0xcadams

package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-zero",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Generate Zero schemas from Drizzle ORM schemas",
   "type": "module",
   "scripts": {

src/drizzle-to-zero.ts

@@ -4,13 +4,7 @@ import type { JSONValue } from "@rocicorp/zero";
  * Represents the basic data types supported by Drizzle ORM.
  * These are the fundamental types that can be used in table column definitions.
  */
-type DrizzleDataType =
-  | "number"
-  | "bigint"
-  | "boolean"
-  | "date"
-  | "string"
-  | "json";
+type DrizzleDataType = "number" | "bigint" | "boolean" | "date";
 
 /**
  * Maps Drizzle data types to their corresponding Zero schema types.
@@ -21,8 +15,6 @@ export const drizzleDataTypeToZeroType = {
   bigint: "number",
   boolean: "boolean",
   date: "number",
-  string: "string",
-  json: "json",
 } as const satisfies Record<DrizzleDataType, string>;
 
 /**
@@ -33,15 +25,31 @@ export type DrizzleDataTypeToZeroType = typeof drizzleDataTypeToZeroType;
 
 /**
  * Represents specific Postgres column types supported by Drizzle ORM.
- * These are more specialized types that need custom handling when converting to Zero.
  */
-type DrizzleColumnType = "PgNumeric" | "PgDateString" | "PgTimestampString";
+type DrizzleColumnType =
+  | "PgText"
+  | "PgChar"
+  | "PgVarchar"
+  | "PgUUID"
+  | "PgEnumColumn"
+  | "PgJsonb"
+  | "PgJson"
+  | "PgNumeric"
+  | "PgDateString"
+  | "PgTimestampString";
 
 /**
  * Maps Postgres-specific Drizzle column types to their corresponding Zero schema types.
  * Handles special cases where Postgres types need specific Zero type representations.
  */
 export const drizzleColumnTypeToZeroType = {
+  PgText: "string",
+  PgChar: "string",
+  PgVarchar: "string",
+  PgUUID: "string",
+  PgEnumColumn: "string",
+  PgJsonb: "json",
+  PgJson: "json",
   PgNumeric: "number",
   PgDateString: "number",
   PgTimestampString: "number",

src/tables.ts

@@ -218,7 +218,7 @@ const createZeroTableSchema = <
 
       if (!type) {
         throw new Error(
-          `drizzle-zero: Unsupported column type: ${column.dataType}. It must be supported by Zero, e.g.: ${Object.keys(drizzleDataTypeToZeroType).join(" | ")}`,
+          `drizzle-zero: Unsupported column type: ${column.columnType} (${column.dataType}). It must be supported by Zero, e.g.: ${Object.keys({ ...drizzleDataTypeToZeroType, ...drizzleColumnTypeToZeroType }).join(" | ")}`,
         );
       }
 

tests/tables.test.ts

@@ -5,15 +5,22 @@ import {
   bigserial,
   boolean,
   char,
+  cidr,
   date,
   doublePrecision,
+  geometry,
+  inet,
   integer,
+  interval,
   json,
   jsonb,
+  line,
+  macaddr,
   numeric,
   pgEnum,
   pgSchema,
   pgTable,
+  point,
   primaryKey,
   real,
   serial,
@@ -180,24 +187,6 @@ describe.concurrent("tables", () => {
     Expect<Equal<typeof result, typeof expected>>;
   });
 
-  test("pg - array types", () => {
-    const table = pgTable("test", {
-      id: text().primaryKey(),
-      tags: text().array().notNull(),
-      scores: jsonb().array(),
-    });
-
-    expect(() =>
-      createZeroTableSchema(table, {
-        id: true,
-        tags: true,
-        scores: true,
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(
-      `[Error: drizzle-zero: Unsupported column type: array. It must be supported by Zero, e.g.: number | bigint | boolean | date | string | json]`,
-    );
-  });
-
   test("pg - complex custom types", () => {
     type UserMetadata = {
       preferences: {
@@ -1225,6 +1214,22 @@ describe.concurrent("tables", () => {
     Expect<Equal<typeof result, typeof expected>>;
   });
 
+  test("pg - invalid column type", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      invalid: text().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        invalid: "someinvalidtype",
+      } as unknown as ColumnsConfig<typeof table>),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Invalid column config for column invalid - expected boolean or object but was string]`,
+    );
+  });
+
   test("pg - invalid column selection", () => {
     const table = pgTable("test", {
       id: text().primaryKey(),
@@ -1241,6 +1246,140 @@ describe.concurrent("tables", () => {
     );
   });
 
+  test("pg - array types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      tags: text().array().notNull(),
+      scores: jsonb().array(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        tags: true,
+        scores: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgArray (array). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - interval types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      interval: interval().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        interval: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgInterval (string). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - cidr types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      cidr: cidr().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        cidr: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgCidr (string). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - macaddr types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      macaddr: macaddr().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        macaddr: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgMacaddr (string). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - inet types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      inet: inet().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        inet: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgInet (string). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - point types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      point: point().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        point: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgPointTuple (array). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - line types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      line: line().notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        line: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgLine (array). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
+  test("pg - geometry types", () => {
+    const table = pgTable("test", {
+      id: text().primaryKey(),
+      location: geometry("location", {
+        type: "point",
+        mode: "xy",
+        srid: 4326,
+      }).notNull(),
+    });
+
+    expect(() =>
+      createZeroTableSchema(table, {
+        id: true,
+        location: true,
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Error: drizzle-zero: Unsupported column type: PgGeometryObject (json). It must be supported by Zero, e.g.: number | bigint | boolean | date | PgText | PgChar | PgVarchar | PgUUID | PgEnumColumn | PgJsonb | PgJson | PgNumeric | PgDateString | PgTimestampString]`,
+    );
+  });
+
   test("pg - no primary key", () => {
     const table = pgTable("test", {
       id: text(),