cogsbox-shape 0.5.192 → 0.5.194

package/dist/schema.js

@@ -7,6 +7,48 @@ export function currentTimeStamp() {
         defaultValue: new Date(),
     };
 }
+function createSqlBuilder(dialect, sqlConfig) {
+    const sqlZodType = (() => {
+        let baseType;
+        if (sqlConfig.pk) {
+            baseType = z.number();
+        }
+        else {
+            switch (sqlConfig.type) {
+                case "int":
+                    baseType = z.number();
+                    break;
+                case "boolean":
+                    baseType = z.number();
+                    break;
+                case "date":
+                case "datetime":
+                case "timestamp":
+                    baseType = z.date();
+                    break;
+                case "enum":
+                    baseType = z.enum(sqlConfig.values);
+                    break;
+                default:
+                    baseType = z.string();
+                    break;
+            }
+        }
+        if (sqlConfig.nullable) {
+            baseType = baseType.nullable();
+        }
+        return baseType;
+    })();
+    const dialectConfig = { ...sqlConfig, dialect };
+    return createBuilder({
+        stage: "sql",
+        sqlConfig: dialectConfig,
+        sqlZod: sqlZodType,
+        initialValue: inferDefaultFromZod(sqlZodType, dialectConfig),
+        clientZod: sqlZodType,
+        validationZod: sqlZodType,
+    });
+}
 export const s = {
     clientInput: (value) => {
         const sample = isFunction(value) ? value({ uuid }) : value;
@@ -60,44 +102,9 @@ export const s = {
         relationType: "manyToMany",
         defaultCount: config?.defaultCount ?? 0,
     }),
-    sql: (sqlConfig) => {
-        const sqlZodType = (() => {
-            let baseType;
-            if (sqlConfig.pk) {
-                baseType = z.number();
-            }
-            else {
-                switch (sqlConfig.type) {
-                    case "int":
-                        baseType = z.number();
-                        break;
-                    case "boolean":
-                        baseType = z.number();
-                        break;
-                    case "date":
-                    case "datetime":
-                    case "timestamp":
-                        baseType = z.date();
-                        break;
-                    default:
-                        baseType = z.string();
-                        break;
-                }
-            }
-            if (sqlConfig.nullable) {
-                baseType = baseType.nullable();
-            }
-            return baseType;
-        })();
-        return createBuilder({
-            stage: "sql",
-            sqlConfig: sqlConfig,
-            sqlZod: sqlZodType,
-            initialValue: inferDefaultFromZod(sqlZodType, sqlConfig),
-            clientZod: sqlZodType,
-            validationZod: sqlZodType,
-        });
-    },
+    sqlite: (sqlConfig) => createSqlBuilder("sqlite", sqlConfig),
+    postgres: (sqlConfig) => createSqlBuilder("postgres", sqlConfig),
+    mysql: (sqlConfig) => createSqlBuilder("mysql", sqlConfig),
 };
 function createBuilder(config) {
     const completedStages = config.completedStages || new Set([config.stage]);
@@ -350,6 +357,7 @@ export function schema(schema) {
     enrichedSchema[SchemaWrapperBrand] = true;
     enrichedSchema.__primaryKeySQL = undefined;
     enrichedSchema.__derives = undefined;
+    enrichedSchema.__refinements = undefined;
     enrichedSchema.primaryKeySQL = function (definer) {
         const pkFieldsOnly = {};
         for (const key in schema) {
@@ -367,6 +375,10 @@ export function schema(schema) {
         enrichedSchema.__derives = derivers;
         return enrichedSchema;
     };
+    enrichedSchema.refine = function (refinements) {
+        enrichedSchema.__refinements = refinements;
+        return enrichedSchema;
+    };
     return enrichedSchema;
 }
 function inferDefaultFromZod(zodType, sqlConfig) {
@@ -387,6 +399,8 @@ function inferDefaultFromZod(zodType, sqlConfig) {
                 case "char":
                 case "longtext":
                     return "";
+                case "enum":
+                    return sqlTypeConfig.default ?? sqlTypeConfig.values[0];
                 case "int":
                     return 0;
                 case "boolean":
@@ -431,6 +445,7 @@ export function createSchema(schema, relations) {
     let pkKeys = [];
     let clientPkKeys = [];
     const derives = schema.__derives;
+    const refinements = schema.__refinements;
     for (const key in fullSchema) {
         const value = fullSchema[key];
         if (key === "_tableName" ||
@@ -633,7 +648,7 @@ export function createSchema(schema, relations) {
         // 2. Map Database ONLY derives directly to the dbObject
         if (derives?.forDb) {
             for (const schemaKey in derives.forDb) {
-                // Resolve custom DB column name if they used s.sql({ field: "custom_name" })
+                // Resolve custom DB column name if they used s.sqlite({ field: "custom_name" })
                 const sqlConfig = fullSchema[schemaKey]?.config?.sql;
                 const dbKey = sqlConfig?.field || schemaKey;
                 dbObject[dbKey] = derives.forDb[schemaKey]?.(clientObject);
@@ -669,22 +684,78 @@ export function createSchema(schema, relations) {
     };
     trackDeriveDependencies(derives?.forClient);
     trackDeriveDependencies(derives?.forDb);
+    const refineDependencies = { server: [], client: [] };
+    const trackRefinementDependencies = (fn, key) => {
+        if (!fn)
+            return;
+        const accessed = new Set();
+        const trackingRow = new Proxy(defaultValues, {
+            get(target, prop, receiver) {
+                if (typeof prop === "string") {
+                    accessed.add(prop);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+        try {
+            fn(trackingRow);
+        }
+        catch (e) { }
+        refineDependencies[key] = Array.from(accessed);
+    };
+    trackRefinementDependencies(refinements?.server, "server");
+    trackRefinementDependencies(refinements?.client, "client");
+    let refinedValidationSchema = finalValidationSchema;
+    if (refinements?.server) {
+        const serverRefine = refinements.server;
+        refinedValidationSchema = finalValidationSchema.superRefine((data, ctx) => {
+            const result = serverRefine(data);
+            if (!result)
+                return;
+            const errors = Array.isArray(result) ? result : [result];
+            for (const err of errors) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: err.message,
+                    path: err.path,
+                });
+            }
+        });
+    }
+    let refinedClientInputSchema = finalClientInputSchema;
+    if (refinements?.client) {
+        const clientRefine = refinements.client;
+        refinedClientInputSchema = finalClientInputSchema.superRefine((data, ctx) => {
+            const result = clientRefine(data);
+            if (!result)
+                return;
+            const errors = Array.isArray(result) ? result : [result];
+            for (const err of errors) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: err.message,
+                    path: err.path,
+                });
+            }
+        });
+    }
     return {
         pk: pkKeys.length ? pkKeys : null,
         clientPk: clientPkKeys.length ? clientPkKeys : null,
         deriveDependencies,
+        refineDependencies,
         isClientRecord,
         sqlSchema: finalSqlSchema,
-        clientInputSchema: finalClientInputSchema,
+        clientInputSchema: refinedClientInputSchema,
         clientSchema: finalClientSchema,
-        serverSchema: finalValidationSchema,
+        serverSchema: refinedValidationSchema,
         defaultValues: defaultValues,
         stateType: {},
         generateDefaults,
         toClient,
         toDb,
         parseForDb: (appData) => {
-            const validData = finalValidationSchema.parse(appData);
+            const validData = refinedValidationSchema.parse(appData);
             return toDb(validData);
         },
         parsePatchForDb: (patchData) => {
@@ -840,6 +911,7 @@ export function createSchemaBox(schemas, resolutions) {
             pk: zodSchemas.pk,
             clientPk: zodSchemas.clientPk,
             deriveDependencies: zodSchemas.deriveDependencies,
+            refineDependencies: zodSchemas.refineDependencies,
             isClientRecord: zodSchemas.isClientRecord,
             generateDefaults: zodSchemas.generateDefaults,
         };
@@ -925,6 +997,7 @@ export function createSchemaBox(schemas, resolutions) {
             pk: entry.pk,
             clientPk: entry.clientPk,
             deriveDependencies: entry.deriveDependencies,
+            refineDependencies: entry.refineDependencies,
             isClientRecord: entry.isClientRecord,
             nav: createNavProxy(tableName, finalRegistry),
             createView: (selection) => {

package/dist/vitest/fullSchema.test.d.ts

@@ -0,0 +1 @@
+export {};