nucleus-core-ts 0.9.802 → 0.9.803

package/dist/fe/types/index.d.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from 'react';
+import type { FilterCondition, SortCondition } from '../../src/types';
 export type SortDirection = 'asc' | 'desc' | null;
 export interface QueryParams {
     page?: number;
@@ -10,15 +11,19 @@ export interface QueryParams {
     filters?: string;
     with?: string;
 }
-export interface FilterCondition {
-    field: string;
-    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in' | 'notIn' | 'isNull' | 'isNotNull';
-    value: unknown;
-}
-export interface SortCondition {
-    field: string;
-    direction: 'asc' | 'desc';
-}
+/**
+ * Re-exported from the server's own definition, not redeclared.
+ *
+ * This file used to carry a NARROWER copy: `field` was required and the
+ * operator list stopped before `arrayOverlaps`, `arrayContains`, `arrayEmpty`,
+ * `or` and `and`. So a query the backend accepts — an `or` group, or a filter
+ * over an array column — was a type error on the client, and the two drifted
+ * every time an operator was added on one side only.
+ *
+ * Types flow from the server outward. A second definition of the same contract
+ * is a second thing to keep right.
+ */
+export type { FilterCondition, FilterOperator, SortCondition } from '../../src/types';
 export interface PaginationMeta {
     page: number;
     limit: number;
@@ -229,4 +234,3 @@ export interface UseNucleusEntityReturn<T extends Record<string, unknown>> {
     setCurrentPage: (page: number) => void;
     refetch: () => void;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.802",
+	"version": "0.9.803",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",

package/scripts/generate-schema.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { selectEmittedTables } from './generate-schema'
+import { generateColumnCode, selectEmittedTables } from './generate-schema'
 
 const table = (table_name: string) => ({ table_name })
 
@@ -76,3 +76,34 @@ describe('selectEmittedTables', () => {
     expect(selectEmittedTables([], sets({}))).toEqual([])
   })
 })
+
+/**
+ * `numeric` and `decimal` are STRING-mode columns in drizzle — Postgres numeric
+ * is arbitrary precision and a JS number cannot carry it. The generator emitted
+ * `.default(0)` for them, producing a schema that ran and did not typecheck.
+ * Nobody reads a generated file, so only `tsc` ever objected — and the project's
+ * typecheck did not cover the folder it landed in.
+ */
+describe('numeric defaults are quoted', () => {
+  const emit = (col: Record<string, unknown>) =>
+    generateColumnCode(col as never, [], 'widgets')
+
+  it('quotes a numeric default, because the column reads as a string', () => {
+    expect(emit({ name: 'position_x', type: 'numeric', notNull: true, default: 0 })).toContain(
+      ".default('0')"
+    )
+    expect(emit({ name: 'rate', type: 'decimal', default: 0.4 })).toContain(".default('0.4')")
+  })
+
+  it('leaves a real number column alone', () => {
+    expect(emit({ name: 'count', type: 'integer', default: 0 })).toContain('.default(0)')
+    expect(emit({ name: 'ratio', type: 'real', default: 1.5 })).toContain('.default(1.5)')
+  })
+
+  it('quotes it with a precision too, where the column carries options', () => {
+    const code = emit({ name: 'lat', type: 'numeric', precision: 10, scale: 8, default: 0 })
+
+    expect(code).toContain('precision: 10')
+    expect(code).toContain(".default('0')")
+  })
+})

package/scripts/generate-schema.ts

@@ -108,6 +108,18 @@ const BASE_COLUMNS: Column[] = [
   { name: 'updated_by', type: 'uuid' },
 ]
 
+/**
+ * Columns drizzle reads and writes as STRINGS.
+ *
+ * Postgres `numeric` is arbitrary precision, so drizzle refuses to round-trip
+ * it through a JS number and types the column as a string. A default therefore
+ * has to be quoted — `.default(0)` compiles to a schema that RUNS and does not
+ * typecheck, which is exactly the kind of defect a generated file hides.
+ */
+function isNumericType(type: string): boolean {
+  return type === 'numeric' || type === 'decimal'
+}
+
 const TYPE_MAP: Record<string, string> = {
   integer: 'integer',
   smallint: 'smallint',
@@ -200,7 +212,7 @@ export function selectEmittedTables<T extends { table_name: string }>(
   )
 }
 
-function generateColumnCode(col: Column, allTables: string[], currentTable?: string): string {
+export function generateColumnCode(col: Column, allTables: string[], currentTable?: string): string {
   const drizzleType = TYPE_MAP[col.type] || 'text'
   let code = ''
 
@@ -255,7 +267,12 @@ function generateColumnCode(col: Column, allTables: string[], currentTable?: str
     } else if (typeof col.default === 'boolean') {
       code += `.default(${col.default})`
     } else if (typeof col.default === 'number') {
-      code += `.default(${col.default})`
+      // `numeric`/`decimal` are STRING-mode columns in drizzle — Postgres numeric
+      // is arbitrary precision and a JS number cannot carry it — so a numeric
+      // default has to be quoted. Emitting the bare number produced a schema
+      // that ran fine and failed `tsc`, which is how it survived: the file is
+      // generated, so nobody reads it, and only a typecheck ever objected.
+      code += isNumericType(col.type) ? `.default('${col.default}')` : `.default(${col.default})`
     } else if (Array.isArray(col.default)) {
       code += `.default(sql\`'{}'\`)`
     } else if (typeof col.default === 'object') {