fix: types simplification

Author: 0xcadams

no-config-integration/tests/utils.ts

@@ -25,12 +25,12 @@ import {
   message,
   user,
 } from "../drizzle/schema";
-import { schema } from "../schema";
+import { schema, type Schema } from "../schema";
 
 const PG_PORT = process.env.PG_VERSION === "17" ? 5732 : 5632;
 const ZERO_PORT = process.env.PG_VERSION === "17" ? 5949 : 4949;
 
-export const getNewZero = async () => {
+export const getNewZero = async (): Promise<Zero<Schema>> => {
   return new Zero({
     server: `http://localhost:${ZERO_PORT}`,
     userID: "1",

no-config-integration/zero-schema.gen.ts

@@ -19,7 +19,7 @@ import type { ZeroCustomType } from "drizzle-zero";
 import type * as drizzleSchema from "./drizzle/schema";
 import type { DrizzleToZeroSchema } from "drizzle-zero";
 
-type ZeroSchema = DrizzleToZeroSchema<typeof drizzleSchema, "snake_case">;
+type ZeroSchema = DrizzleToZeroSchema<typeof drizzleSchema>;
 
 /**
  * The Zero schema object.

src/cli/shared.ts

@@ -70,7 +70,7 @@ export async function getGeneratedSchema({
     zeroSchemaGenerated.addTypeAlias({
       name: "ZeroSchema",
       isExported: false,
-      type: `DrizzleToZeroSchema<typeof drizzleSchema${result.drizzleCasing ? `, "${result.drizzleCasing}"` : ""}>`,
+      type: `DrizzleToZeroSchema<typeof drizzleSchema>`,
     });
 
     zeroSchemaSpecifier = "ZeroSchema";

src/relations.ts

@@ -1,5 +1,4 @@
 import { createSchema } from "@rocicorp/zero";
-import type { RelationshipsSchema } from "@rocicorp/zero/react";
 import {
   createTableRelationsHelpers,
   getTableName,
@@ -97,7 +96,6 @@ type ManyConfig<TDrizzleSchema extends Record<string, unknown>> = {
  */
 type DrizzleToZeroSchema<
   TDrizzleSchema extends { [K in string]: unknown },
-  TCasing extends ZeroTableCasing = undefined,
   TColumnConfig extends
     TableColumnsConfig<TDrizzleSchema> = DefaultTableColumnsConfig<TDrizzleSchema>,
 > = {
@@ -108,14 +106,11 @@ type DrizzleToZeroSchema<
       ? ZeroTableBuilderSchema<
           K & string,
           TDrizzleSchema[K],
-          TColumnConfig[K & keyof TColumnConfig],
-          TCasing
-        > & {_type:   TColumnConfig[K & keyof TColumnConfig]}
+          TColumnConfig[K & keyof TColumnConfig]
+        >
       : never;
   };
-  readonly relationships: {
-    readonly [table: string]: RelationshipsSchema;
-  };
+  readonly relationships: any;
 };
 
 /**
@@ -256,7 +251,7 @@ const drizzleZeroConfig = <
      */
     readonly debug?: boolean;
   },
-): Flatten<DrizzleToZeroSchema<TDrizzleSchema, TCasing, TColumnConfig>> => {
+): Flatten<DrizzleToZeroSchema<TDrizzleSchema, TColumnConfig>> => {
   let tables: any[] = [];
 
   const tableColumnNamesForSourceTable = new Map<string, Set<string>>();
@@ -642,11 +637,7 @@ const drizzleZeroConfig = <
       name: key,
       relationships: value,
     })),
-  } as any) as unknown as DrizzleToZeroSchema<
-    TDrizzleSchema,
-    TCasing,
-    TColumnConfig
-  >;
+  } as any) as unknown as DrizzleToZeroSchema<TDrizzleSchema, TColumnConfig>;
 
   debugLog(
     config?.debug,

src/tables.ts

@@ -19,12 +19,7 @@ import {
   drizzleDataTypeToZeroType,
   type ZeroTypeToTypescriptType,
 } from "./drizzle-to-zero";
-import type {
-  ColumnNames,
-  Columns,
-  FindPrimaryKeyFromTable,
-  HasCapital,
-} from "./types";
+import type { ColumnNames, Columns, FindPrimaryKeyFromTable } from "./types";
 import { debugLog, typedEntries } from "./util";
 
 export type { ColumnBuilder, ReadonlyJSONValue, TableBuilderWithColumns };
@@ -72,9 +67,6 @@ export type ColumnsConfig<TTable extends Table> =
 
 /**
  * Maps a Drizzle column type to its corresponding Zero type.
- * @template TTable The Drizzle table type
- * @template KColumn The column name
- * @template CD The column definition type
  */
 type ZeroMappedColumnType<
   TTable extends Table,
@@ -92,9 +84,6 @@ type ZeroMappedColumnType<
 /**
  * Maps a Drizzle column to its corresponding TypeScript type in Zero.
  * Handles special cases like enums and custom types.
- * @template TTable The Drizzle table type
- * @template KColumn The column name
- * @template CD The column definition type
  */
 type ZeroMappedCustomType<
   TTable extends Table,
@@ -118,63 +107,29 @@ type ZeroMappedCustomType<
 
 /**
  * Defines the structure of a column in the Zero schema.
- * @template TTable The Drizzle table type
- * @template KColumn The column name
- * @template CD The column definition type
  */
 type ZeroColumnDefinition<
   TTable extends Table,
   KColumn extends ColumnNames<TTable>,
-  TCasing extends ZeroTableCasing,
-  CD extends ColumnDefinition<TTable, KColumn>["_"] = ColumnDefinition<
-    TTable,
-    KColumn
-  >["_"],
-  BaseDefinition extends {
-    optional: false;
-    type: ZeroMappedColumnType<TTable, KColumn>;
-    customType: ZeroMappedCustomType<TTable, KColumn>;
-  } = {
-    optional: false;
-    type: ZeroMappedColumnType<TTable, KColumn>;
-    customType: ZeroMappedCustomType<TTable, KColumn>;
-  },
-  BaseOptional extends Omit<BaseDefinition, "optional"> & {
-    optional: true;
-  } = Omit<BaseDefinition, "optional"> & { optional: true },
-> = (CD extends {
-  hasDefault: true;
-  hasRuntimeDefault: false;
-}
-  ? BaseOptional
-  : CD extends { notNull: true }
-    ? BaseDefinition
-    : Omit<BaseDefinition, "optional"> & { optional: true }) &
-  (CD extends { name: KColumn }
-    ? TCasing extends "snake_case"
-      ? HasCapital<CD["name"]> extends true
-        ? { serverName: string }
-        : {}
-      : TCasing extends "camelCase"
-        ? HasCapital<CD["name"]> extends false
-          ? { serverName: string }
-          : {}
-        : {}
-    : { serverName: string });
+> = {
+  optional: boolean;
+  type: ZeroMappedColumnType<TTable, KColumn>;
+  customType: ZeroMappedCustomType<TTable, KColumn>;
+  serverName?: string;
+};
 
 /**
  * Maps the columns configuration to their Zero schema definitions.
  */
 export type ZeroColumns<
   TTable extends Table,
   TColumnConfig extends ColumnsConfig<TTable> | undefined,
-  TCasing extends ZeroTableCasing,
 > = {
   [KColumn in ColumnNames<TTable>]: KColumn extends keyof TColumnConfig
     ? TColumnConfig[KColumn & keyof TColumnConfig] extends ColumnBuilder<any>
       ? TColumnConfig[KColumn & keyof TColumnConfig]["schema"]
-      : ZeroColumnDefinition<TTable, KColumn, TCasing>
-    : ZeroColumnDefinition<TTable, KColumn, TCasing>;
+      : ZeroColumnDefinition<TTable, KColumn>
+    : ZeroColumnDefinition<TTable, KColumn>;
 };
 
 /**
@@ -184,13 +139,12 @@ export type ZeroTableBuilderSchema<
   TTableName extends string,
   TTable extends Table,
   TColumnConfig extends ColumnsConfig<TTable> | undefined,
-  TCasing extends ZeroTableCasing,
 > = {
   name: TTableName;
   primaryKey: FindPrimaryKeyFromTable<TTable> extends [never]
     ? readonly [string, ...string[]]
     : readonly [string, ...string[]] & FindPrimaryKeyFromTable<TTable>;
-  columns: ZeroColumns<TTable, TColumnConfig, TCasing>;
+  columns: ZeroColumns<TTable, TColumnConfig>;
 }; // Zero does not support this properly yet: & (TTable['_']['name'] extends TTableName ? {} : { serverName: string });
 
 /**
@@ -200,9 +154,8 @@ type ZeroTableBuilder<
   TTableName extends string,
   TTable extends Table,
   TColumnConfig extends ColumnsConfig<TTable>,
-  TCasing extends ZeroTableCasing,
 > = TableBuilderWithColumns<
-  Readonly<ZeroTableBuilderSchema<TTableName, TTable, TColumnConfig, TCasing>>
+  Readonly<ZeroTableBuilderSchema<TTableName, TTable, TColumnConfig>>
 >;
 
 /**
@@ -242,7 +195,7 @@ const createZeroTableBuilder = <
    * The casing to use for the table name.
    */
   casing?: TCasing,
-): ZeroTableBuilder<TTableName, TTable, TColumnConfig, TCasing> => {
+): ZeroTableBuilder<TTableName, TTable, TColumnConfig> => {
   const actualTableName = getTableName(table);
   const tableColumns = getTableColumns(table);
   const tableConfig = getTableConfigForDatabase(table);
@@ -316,10 +269,10 @@ const createZeroTableBuilder = <
 
       const type =
         drizzleColumnTypeToZeroType[
-          column.columnType as keyof DrizzleColumnTypeToZeroType
+          column.columnType as keyof typeof drizzleColumnTypeToZeroType
         ] ??
         drizzleDataTypeToZeroType[
-          column.dataType as keyof DrizzleDataTypeToZeroType
+          column.dataType as keyof typeof drizzleDataTypeToZeroType
         ] ??
         null;
 
@@ -394,8 +347,7 @@ const createZeroTableBuilder = <
     .primaryKey(...primaryKeys) as ZeroTableBuilder<
     TTableName,
     TTable,
-    TColumnConfig,
-    TCasing
+    TColumnConfig
   >;
 };
 

src/types.ts

@@ -114,19 +114,6 @@ export type FindTableByName<
   Table<any>
 >;
 
-/**
- * Type guard that checks if a string has a capital letter.
- * @template S The string to check
- */
-export type HasCapital<S extends string> =
-  S extends `${infer First}${infer Rest}`
-    ? First extends Uppercase<First>
-      ? First extends Lowercase<First>
-        ? HasCapital<Rest>
-        : true
-      : HasCapital<Rest>
-    : false;
-
 /**
  * Utility type that flattens an object type by removing any intermediate interfaces.
  * @template T The type to flatten

tests/cli.test.ts

@@ -8,7 +8,6 @@ import {
 } from "../src/cli/config";
 import { getGeneratedSchema } from "../src/cli/shared";
 import type { DrizzleToZeroSchema } from "../src/relations";
-import * as oneToOneSchema from "./schemas/one-to-one.zero";
 
 describe("getGeneratedSchema", () => {
   let tsProject: Project;
@@ -43,7 +42,27 @@ describe("getGeneratedSchema", () => {
       tsProject,
       result: {
         type: "config",
-        zeroSchema: oneToOneSchema.schema,
+        zeroSchema: {
+          tables: {
+            users: {
+              name: "users",
+              primaryKey: ["id"],
+              columns: {
+                id: {
+                  type: "integer",
+                  optional: false,
+                  customType: undefined,
+                },
+                name: {
+                  type: "string",
+                  optional: false,
+                  customType: undefined,
+                },
+              },
+            },
+          },
+          relationships: {},
+        },
         exportName: "schema",
         zeroSchemaTypeDeclarations: zeroSchemaTypeDecl,
       },
@@ -54,37 +73,12 @@ describe("getGeneratedSchema", () => {
     expect(generatedSchema).toContain("export const schema = {");
     expect(generatedSchema).toContain('"users": {');
 
-    // Check actual schema to ensure our expectations match reality
-    if (!generatedSchema.includes('"profileInfo": {')) {
-      // If profileInfo isn't in the schema, check what tables actually are in the test schema
-      console.log(
-        "Tables in schema:",
-        Object.keys(oneToOneSchema.schema.tables),
-      );
-      // Adjust test to match actual schema structure
-      const tables = Object.keys(oneToOneSchema.schema.tables);
-      expect(tables.length).toBeGreaterThan(0);
-      tables.forEach((table) => {
-        expect(generatedSchema).toContain(`"${table}": {`);
-      });
-    } else {
-      expect(generatedSchema).toContain('"profileInfo": {');
-    }
-
     expect(generatedSchema).toContain("export type Schema = typeof schema");
 
     // Check for fields from the one-to-one schema
     expect(generatedSchema).toContain('"id": {');
     expect(generatedSchema).toContain('"name": {');
 
-    // Similarly, check for these fields conditionally
-    if (generatedSchema.includes('"userId": {')) {
-      expect(generatedSchema).toContain('"userId": {');
-    }
-    if (generatedSchema.includes('"metadata": {')) {
-      expect(generatedSchema).toContain('"metadata": {');
-    }
-
     // Verify the auto-generated comment header
     expect(generatedSchema).toContain(
       "This file was automatically generated by drizzle-zero",
@@ -403,7 +397,7 @@ describe("getGeneratedSchema", () => {
               },
             },
             relationships: {},
-          } as any, // Type assertion to avoid TypeScript errors
+          },
           drizzleSchemaSourceFile: mockSource,
           drizzleCasing: null,
         },
@@ -436,7 +430,22 @@ describe("getGeneratedSchema", () => {
       tsProject,
       result: {
         type: "config",
-        zeroSchema: oneToOneSchema.schema,
+        zeroSchema: {
+          tables: {
+            users: {
+              name: "users",
+              primaryKey: ["id"],
+              columns: {
+                id: {
+                  type: "integer",
+                  optional: false,
+                  customType: undefined,
+                },
+              },
+            },
+          },
+          relationships: {},
+        },
         exportName: "schema",
         zeroSchemaTypeDeclarations: zeroSchemaTypeDecl,
       },