prostgles-server 2.0.333 → 2.0.334

package/lib/validation.ts

@@ -10,53 +10,55 @@ type BaseOptions = {
 };
 
 type SimpleType = BaseOptions & ({
-  type:  
+  type:
   | "number" | "boolean" | "integer" | "string" | "any"
   | "number[]" | "boolean[]" | "integer[]" | "string[]" | "any[]"
   | ValidationSchema;
 
 } | {
-  oneOf: readonly any[];
+  enum: readonly any[];
 })
 
-export type OneOfTypes = BaseOptions & {
-  oneOfTypes: readonly ValidationSchema[];
+export type OneOf = BaseOptions & {
+  oneOf: readonly ValidationSchema[];
 }
-type FieldType = SimpleType | OneOfTypes;
-
-type GetType<T extends FieldType> = 
-| T extends { type: ValidationSchema }? SchemaObject<T["type"]> : 
-| T extends { type: "number" }? number:
-| T extends { type: "boolean" }? boolean:
-| T extends { type: "integer" }? number:
-| T extends { type: "string" }? string:
-| T extends { type: "any" }? any:
-| T extends { type: "number[]" }? number[]:
-| T extends { type: "boolean[]" }? boolean[]:
-| T extends { type: "integer[]" }? number[]:
-| T extends { type: "string[]" }? string[]:
-| T extends { type: "any[]" }? any[]:
-| T extends { oneOf: readonly any[] }? T["oneOf"][number] : 
-
-/** This needs fixing */
-| T extends { oneOfTypes: readonly ValidationSchema[] }? SchemaObject<T["oneOfTypes"][number]> : 
-any;
+type FieldType = SimpleType | OneOf;
+
+type GetType<T extends FieldType> =
+  | T extends { type: ValidationSchema } ? SchemaObject<T["type"]> :
+  | T extends { type: "number" } ? number :
+  | T extends { type: "boolean" } ? boolean :
+  | T extends { type: "integer" } ? number :
+  | T extends { type: "string" } ? string :
+  | T extends { type: "any" } ? any :
+  | T extends { type: "number[]" } ? number[] :
+  | T extends { type: "boolean[]" } ? boolean[] :
+  | T extends { type: "integer[]" } ? number[] :
+  | T extends { type: "string[]" } ? string[] :
+  | T extends { type: "any[]" } ? any[] :
+  | T extends { enum: readonly any[] } ? T["enum"][number] :
+
+  /** This needs fixing */
+  | T extends { oneOf: readonly ValidationSchema[] } ? SchemaObject<T["oneOf"][number]> :
+  any;
 
 export type ValidationSchema = Record<string, FieldType>;
 export type SchemaObject<S extends ValidationSchema> = ({
-  [K in keyof S as S[K]["optional"] extends true? K : never]?: GetType<S[K]>
+  [K in keyof S as S[K]["optional"] extends true ? K : never]?: GetType<S[K]>
 } & {
-  [K in keyof S as S[K]["optional"] extends true? never : K]: GetType<S[K]>
-});
+    [K in keyof S as S[K]["optional"] extends true ? never : K]: GetType<S[K]>
+  });
 
 /** tests */
 const s = {
   a: { type: "boolean" },
   c: { type: { c1: { type: "string" } } },
-  o: { oneOfTypes: [
-    { z: { type: "integer" } },
-    { z1: { type: "integer" } }
-  ] }
+  o: {
+    oneOf: [
+      { z: { type: "integer" } },
+      { z1: { type: "integer" } }
+    ]
+  }
 } as const;
 const ss: SchemaObject<typeof s> = {
   a: true,
@@ -69,30 +71,30 @@ const ss: SchemaObject<typeof s> = {
 export function validate<T>(obj: T, key: keyof T, validation: FieldType): boolean {
   let err = `The provided value for ${JSON.stringify(key)} is of invalid type. Expecting `;
   const val = obj[key];
-  if("type" in validation && validation.type){
-    if(typeof validation.type !== "string"){
+  if ("type" in validation && validation.type) {
+    if (typeof validation.type !== "string") {
       getKeys(validation.type).forEach(subKey => {
         validate(val, subKey as any, (validation.type as ValidationSchema)[subKey])
       });
     }
     err += validation.type;
-    if(validation.type === "boolean" && typeof val !== validation.type) throw new Error(err)
-    if(validation.type === "string" && typeof val !== validation.type) throw new Error(err)
-    if(validation.type === "number" && !Number.isFinite(val)) throw new Error(err)
-    if(validation.type === "integer" && !Number.isInteger(val)) throw new Error(err)
-  } else if("oneOf" in validation && validation.oneOf){
-    err += `on of: ${validation.oneOf}`;
-    if(!validation.oneOf.includes(val)) throw new Error(err)
+    if (validation.type === "boolean" && typeof val !== validation.type) throw new Error(err)
+    if (validation.type === "string" && typeof val !== validation.type) throw new Error(err)
+    if (validation.type === "number" && !Number.isFinite(val)) throw new Error(err)
+    if (validation.type === "integer" && !Number.isInteger(val)) throw new Error(err)
+  } else if ("enum" in validation && validation.enum) {
+    err += `on of: ${validation.enum}`;
+    if (!validation.enum.includes(val)) throw new Error(err)
   }
   return true
 }
 
-export function validateSchema<S extends ValidationSchema>(schema: S, obj: SchemaObject<S>, objName?: string, optional = false){
-  if((!schema || isEmpty(schema)) && !optional) throw new Error(`Expecting ${objName} to be defined`);
+export function validateSchema<S extends ValidationSchema>(schema: S, obj: SchemaObject<S>, objName?: string, optional = false) {
+  if ((!schema || isEmpty(schema)) && !optional) throw new Error(`Expecting ${objName} to be defined`);
   getKeys(schema).forEach(k => validate(obj as any, k, schema[k]));
 }
 
-export function getPGCheckConstraint(args: { escapedFieldName: string; schema: ValidationSchema | OneOfTypes, nullable: boolean; isRootQuery?: boolean; optional?: boolean; }, depth: number): string {
+export function getPGCheckConstraint(args: { escapedFieldName: string; schema: ValidationSchema | OneOf, nullable: boolean; isRootQuery?: boolean; optional?: boolean; }, depth: number): string {
   const { schema: s, escapedFieldName, nullable, optional, isRootQuery } = args;
 
   const jsToPGtypes = {
@@ -108,40 +110,40 @@ export function getPGCheckConstraint(args: { escapedFieldName: string; schema: V
     const checks: string[] = [];
     const valAsJson = `${escapedFieldName}->${asValue(k)}`;
     const valAsText = `${escapedFieldName}->>${asValue(k)}`;
-    if(t.nullable) checks.push(`${valAsJson} IS NULL`);
-    if(t.optional) checks.push(`${escapedFieldName} ? ${asValue(k)} = FALSE`);
-
-    if("oneOfTypes" in t){
-      checks.push(`(${t.oneOfTypes.map(subType => getPGCheckConstraint({ escapedFieldName: valAsJson, schema: subType, nullable, optional: t.optional }, depth + 1)).join(" OR ")})`)
-    } else if("oneOf" in t){
-      if(!t.oneOf.length || t.oneOf.some(v => v === undefined || !["number", "boolean", "string", null].includes(typeof v))) {
-        throw new Error(`Invalid ValidationSchema for property: ${k} of field ${escapedFieldName}: oneOf cannot be empty AND can only contain: numbers, text, boolean, null`);
+    if (t.nullable) checks.push(`${valAsJson} IS NULL`);
+    if (t.optional) checks.push(`${escapedFieldName} ? ${asValue(k)} = FALSE`);
+
+    if ("oneOf" in t) {
+      checks.push(`(${t.oneOf.map(subType => getPGCheckConstraint({ escapedFieldName: valAsJson, schema: subType, nullable, optional: t.optional }, depth + 1)).join(" OR ")})`)
+    } else if ("enum" in t) {
+      if (!t.enum.length || t.enum.some(v => v === undefined || !["number", "boolean", "string", null].includes(typeof v))) {
+        throw new Error(`Invalid ValidationSchema for property: ${k} of field ${escapedFieldName}: enum cannot be empty AND can only contain: numbers, text, boolean, null`);
       }
-      const oneOfHasNull = t.oneOf.includes(null);
-      if(oneOfHasNull) checks.push(`${valAsText} IS NULL`);
-    const oneOf = t.oneOf.filter(o => o !== null);
-      oneOf.forEach(o => {
+      const oneOfHasNull = t.enum.includes(null);
+      if (oneOfHasNull) checks.push(`${valAsText} IS NULL`);
+      const _enum = t.enum.filter(o => o !== null);
+      _enum.forEach(o => {
         checks.push(`(${valAsText})${(jsToPGtypes as any)[typeof o]} = ${asValue(o)}`);
       })
-    } else if("type" in t){
-      if(typeof t.type === "string") {
-        if(t.type.endsWith("[]")){
+    } else if ("type" in t) {
+      if (typeof t.type === "string") {
+        if (t.type.endsWith("[]")) {
           const correctType = t.type.slice(0, -2);
-          let elemCheck = correctType === "any"? "" : `AND ('{' || right(left(${valAsText},-1),-1) || '}')${jsToPGtypes[correctType as keyof typeof jsToPGtypes]}[] IS NOT NULL`
+          let elemCheck = correctType === "any" ? "" : `AND ('{' || right(left(${valAsText},-1),-1) || '}')${jsToPGtypes[correctType as keyof typeof jsToPGtypes]}[] IS NOT NULL`
           checks.push(`jsonb_typeof(${valAsJson}) = 'array' ${elemCheck}`)
         } else {
           const correctType = t.type.replace("integer", "number");
-          if(correctType !== "any"){
+          if (correctType !== "any") {
             checks.push(`jsonb_typeof(${valAsJson}) = ${asValue(correctType)} `)
           }
         }
       } else {
         const check = getPGCheckConstraint({ escapedFieldName: valAsJson, schema: t.type, nullable: !!t.nullable, optional: !!t.optional }, depth + 1).trim();
-        if(check) checks.push(`(${check})`)
+        if (check) checks.push(`(${check})`)
       }
     }
     const result = checks.join(" OR ")
-    if(!depth) return `COALESCE(${result}, false)`
+    if (!depth) return `COALESCE(${result}, false)`
     return result
   }
 
@@ -149,21 +151,21 @@ export function getPGCheckConstraint(args: { escapedFieldName: string; schema: V
 
   const checks: string[] = [];
   let typeChecks = "";
-  if(isOneOfTypes(s)){
-    typeChecks = s.oneOfTypes.map(t => `(${getSchemaChecks(t)})` ).join(" OR ");
+  if (isOneOfTypes(s)) {
+    typeChecks = s.oneOf.map(t => `(${getSchemaChecks(t)})`).join(" OR ");
   } else {
     typeChecks = getSchemaChecks(s);
   }
-  if(nullable) checks.push(` ${escapedFieldName} IS NULL `);
-  checks.push(`jsonb_typeof(${escapedFieldName}) = 'object' ${typeChecks? ` AND (${typeChecks})` : "" }`);
+  if (nullable) checks.push(` ${escapedFieldName} IS NULL `);
+  checks.push(`jsonb_typeof(${escapedFieldName}) = 'object' ${typeChecks ? ` AND (${typeChecks})` : ""}`);
   return checks.join(" OR ");
 }
 type ColOpts = { nullable?: boolean };
-const isOneOfTypes = (s: ValidationSchema | OneOfTypes): s is OneOfTypes => {
+const isOneOfTypes = (s: ValidationSchema | OneOf): s is OneOf => {
 
-  if("oneOfTypes" in s){
-    if(!Array.isArray(s.oneOfTypes)){
-      throw "Expecting oneOfTypes to be an array of types";
+  if ("oneOf" in s) {
+    if (!Array.isArray(s.oneOf)) {
+      throw "Expecting oneOf to be an array of types";
     }
     return true;
   }
@@ -172,71 +174,71 @@ const isOneOfTypes = (s: ValidationSchema | OneOfTypes): s is OneOfTypes => {
 
 export function getSchemaTSTypes(schema: ValidationSchema, leading = "", isOneOf = false): string {
   const getFieldType = (def: FieldType) => {
-    const nullType = (def.nullable? `null | ` : "");
-    if("type" in def){
-      if(typeof def.type === "string"){
+    const nullType = (def.nullable ? `null | ` : "");
+    if ("type" in def) {
+      if (typeof def.type === "string") {
         const correctType = def.type.replace("integer", "number")
         return nullType + correctType
       } else {
         return nullType + getSchemaTSTypes(def.type, "", true)
       }
-    } else if("oneOf" in def){
-      return nullType + def.oneOf.map(v => asValue(v)).join(" | ")
-    } else if("oneOfTypes" in def){
-      return (def.nullable? `\n${leading}  | null` : "") + def.oneOfTypes.map(v => `\n${leading}  | ` + getSchemaTSTypes(v, "", true)).join("")
+    } else if ("enum" in def) {
+      return nullType + def.enum.map(v => asValue(v)).join(" | ")
+    } else if ("oneOf" in def) {
+      return (def.nullable ? `\n${leading}  | null` : "") + def.oneOf.map(v => `\n${leading}  | ` + getSchemaTSTypes(v, "", true)).join("")
     } else throw "Unexpected getSchemaTSTypes"
   }
 
-  let spacing = isOneOf? " " : "  ";
+  let spacing = isOneOf ? " " : "  ";
 
   let res = `${leading}{ \n` + getKeys(schema).map(k => {
     const def = schema[k];
-    return `${leading}${spacing}${k}${def.optional? "?" : ""}: ` + getFieldType(def) + ";";
-  }).join("\n") + ` \n${leading}}${isOneOf? "" : ";"}`;
-  
+    return `${leading}${spacing}${k}${def.optional ? "?" : ""}: ` + getFieldType(def) + ";";
+  }).join("\n") + ` \n${leading}}${isOneOf ? "" : ";"}`;
+
   /** Keep single line */
-  if(isOneOf) res = res.split("\n").join("")
+  if (isOneOf) res = res.split("\n").join("")
   return res;
 }
 
-export function getJSONBSchemaTSTypes(schema: ValidationSchema | OneOfTypes, colOpts: ColOpts, leading = "", isOneOf = false): string {
-  if(isOneOfTypes(schema)){
-    return (colOpts.nullable? `\n${leading}  | null` : "") + schema.oneOfTypes.map(s => `\n${leading}  | ` + getSchemaTSTypes(s, "", true)).join("")
+export function getJSONBSchemaTSTypes(schema: ValidationSchema | OneOf, colOpts: ColOpts, leading = "", isOneOf = false): string {
+  if (isOneOfTypes(schema)) {
+    return (colOpts.nullable ? `\n${leading}  | null` : "") + schema.oneOf.map(s => `\n${leading}  | ` + getSchemaTSTypes(s, "", true)).join("")
   } else {
-    return (colOpts.nullable? `null | ` : "") + getSchemaTSTypes(schema, leading, isOneOf);
+    return (colOpts.nullable ? `null | ` : "") + getSchemaTSTypes(schema, leading, isOneOf);
   }
 }
 
 // type JSONSchema = 
 const getJSONSchemaObject = <T extends ValidationSchema>(objDef: T): Record<keyof T, any> => {
   const resultType: Record<keyof T, any> = {} as any;
-  
+
   return getKeys(objDef).reduce((a, k) => {
     const itemSchema: FieldType = objDef[k];
     const { nullable, optional, description, title } = itemSchema;
     let item = {} as any;
 
-    if("type" in itemSchema){
+    if ("type" in itemSchema) {
       const { type } = itemSchema;
       /**
        * Is primitive or any
        */
-      if(typeof type === "string"){
-        const arrayType = type.endsWith("[]")? type.slice(0, -2) : undefined;
-        if(arrayType){
+      if (typeof type === "string") {
+        const arrayType = type.endsWith("[]") ? type.slice(0, -2) : undefined;
+        if (arrayType) {
           item = {
             type: "array",
-            items: { type: arrayType === "any"? {} : arrayType }
+            items: { type: arrayType === "any" ? {} : arrayType }
           }
         } else {
           item = {
-            type: type === "any"? {} : type
+            type: type === "any" ? {} : type
           }
         }
 
-      /**
-       * Is object
-       */
+        /**
+         * Is object
+         */
       } else {
         item = {
           type: "object",
@@ -245,33 +247,33 @@ const getJSONSchemaObject = <T extends ValidationSchema>(objDef: T): Record<keyo
 
       }
 
-    } else if("oneOf" in itemSchema) {
-      item = { 
-        type: typeof itemSchema.oneOf[0]!,
-        "enum": itemSchema.oneOf //.concat(nullable? [null] : [])
+    } else if ("enum" in itemSchema) {
+      item = {
+        type: typeof itemSchema.enum[0]!,
+        "enum": itemSchema.enum //.concat(nullable? [null] : [])
       }
-    } else if("oneOfTypes" in itemSchema) {
+    } else if ("oneOf" in itemSchema) {
       item = {
-        oneOf: itemSchema.oneOfTypes.map(t => getJSONSchemaObject(t))
+        oneOf: itemSchema.oneOf.map(t => getJSONSchemaObject(t))
       }
     } else {
-      throw new Error("Unexpected jsonbSchema itemSchema" + JSON.stringify({itemSchema, objDef}, null, 2))
+      throw new Error("Unexpected jsonbSchema itemSchema" + JSON.stringify({ itemSchema, objDef }, null, 2))
     }
 
-    if(nullable){
+    if (nullable) {
       const nullDef = { type: "null" }
-      if(item.oneOf) item.oneOf.push(nullDef)
+      if (item.oneOf) item.oneOf.push(nullDef)
       else item = {
         oneOf: [item, nullDef]
       }
     }
 
-    return { 
+    return {
       ...a,
       [k]: {
         ...item,
         required: !optional,
-        description, 
+        description,
         title,
       }
     }
@@ -281,11 +283,11 @@ const getJSONSchemaObject = <T extends ValidationSchema>(objDef: T): Record<keyo
 export function getJSONBSchemaAsJSONSchema(tableName: string, colName: string, columnConfig: BaseColumn<{ en: 1 }> & JSONBColumnDef): AnyObject {
 
   const schema = columnConfig.jsonbSchema;
-  
-  let jSchema = getJSONSchemaObject({ 
-      field1: isOneOfTypes(schema)? schema as OneOfTypes : 
-      { type: schema as ValidationSchema } 
-    }).field1;
+
+  let jSchema = getJSONSchemaObject({
+    field1: isOneOfTypes(schema) ? schema as OneOf :
+      { type: schema as ValidationSchema }
+  }).field1;
 
   return {
     "$id": `${tableName}.${colName}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "2.0.333",
+  "version": "2.0.334",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/client/PID.txt

@@ -1 +1 @@
-70976
+77759

package/tests/isomorphic_queries.js

@@ -573,10 +573,10 @@ async function isomorphic(db) {
       tjson: {
         json: { jsonbSchema: {
           a: { type: "boolean" },
-          arr: { oneOf: ["1", "2", "3"] },
-          arr1: { oneOf: [1, 2, 3] },
+          arr: { enum: ["1", "2", "3"] },
+          arr1: { enum: [1, 2, 3] },
           arr2: { type: "integer[]" },
-          o: { oneOfTypes: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true },
+          o: { oneOf: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true },
           }
         }
       },

package/tests/isomorphic_queries.ts

@@ -656,10 +656,10 @@ export default async function isomorphic(db: Required<DBHandlerServer> | Require
   tjson: {
     json: { jsonbSchema: { 
       a: { type: "boolean" },
-      arr: { oneOf: ["1", "2", "3"] },
-      arr1: { oneOf: [1, 2, 3] },
+      arr: { enum: ["1", "2", "3"] },
+      arr1: { enum: [1, 2, 3] },
       arr2: { type: "integer[]" },
-      o: { oneOfTypes: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true },
+      o: { oneOf: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true },
       }  
     }
   },

package/tests/server/index.js

@@ -89,11 +89,11 @@ function dd() {
             columns: {
                 id: { sqlDefinition: `SERIAL PRIMARY KEY ` },
                 email: { sqlDefinition: `TEXT NOT NULL` },
-                status: { oneOf: ["active", "disabled", "pending"] },
+                status: { enum: ["active", "disabled", "pending"] },
                 preferences: { defaultValue: "{}",
                     jsonbSchema: {
                         showIntro: { type: "boolean", optional: true },
-                        theme: { oneOf: ["light", "dark", "auto"], optional: true },
+                        theme: { enum: ["light", "dark", "auto"], optional: true },
                         others: { type: "any[]" }
                     }
                 },
@@ -104,18 +104,18 @@ function dd() {
             columns: {
                 json: { jsonbSchema: {
                         a: { type: "boolean" },
-                        arr: { oneOf: ["1", "2", "3"] },
-                        arr1: { oneOf: [1, 2, 3] },
+                        arr: { enum: ["1", "2", "3"] },
+                        arr1: { enum: [1, 2, 3] },
                         arr2: { type: "integer[]" },
                         arrStr: { type: "string[]", optional: true, nullable: true },
-                        o: { oneOfTypes: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true, nullable: true },
+                        o: { oneOf: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true, nullable: true },
                     }
                 },
-                colOneOf: { oneOf: ["a", "b", "c"] },
+                colOneOf: { enum: ["a", "b", "c"] },
                 status: {
                     nullable: true,
                     jsonbSchema: {
-                        oneOfTypes: [
+                        oneOf: [
                             { ok: { type: "string" } },
                             { err: { type: "string" } },
                             {
@@ -131,10 +131,10 @@ function dd() {
                 jsonOneOf: {
                     nullable: true,
                     jsonbSchema: {
-                        oneOfTypes: [
-                            { command: { oneOf: ["a"] } },
+                        oneOf: [
+                            { command: { enum: ["a"] } },
                             {
-                                command: { oneOf: ["b"] },
+                                command: { enum: ["b"] },
                                 option: { type: "integer[]" }
                             }
                         ]

package/tests/server/index.ts

@@ -110,11 +110,11 @@ function dd(){
       columns: {
         id:           { sqlDefinition: `SERIAL PRIMARY KEY ` },
         email:        { sqlDefinition: `TEXT NOT NULL` },
-        status:       { oneOf: ["active", "disabled", "pending"] },
+        status:       { enum: ["active", "disabled", "pending"] },
         preferences:  { defaultValue: "{}", 
           jsonbSchema: { 
             showIntro:  { type: "boolean", optional: true },
-            theme:      { oneOf: ["light", "dark", "auto"], optional: true },
+            theme:      { enum: ["light", "dark", "auto"], optional: true },
 						others: 		{ type: "any[]" }
           } 
         },
@@ -125,18 +125,18 @@ function dd(){
 			columns: {
 				json: { jsonbSchema: { 
 						a: { type: "boolean" },
-						arr: { oneOf: ["1", "2", "3"] },
-						arr1: { oneOf: [1, 2, 3] },
+						arr: { enum: ["1", "2", "3"] },
+						arr1: { enum: [1, 2, 3] },
 						arr2: { type: "integer[]" },
 						arrStr: { type: "string[]", optional: true, nullable: true },
-						o: { oneOfTypes: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true, nullable: true },
+						o: { oneOf: [{ o1: { type: "integer" } }, { o2: { type: "boolean" } }], optional: true, nullable: true },
 					}  
 				},
-				colOneOf: { oneOf: ["a", "b", "c"] },
+				colOneOf: { enum: ["a", "b", "c"] },
 				status:  {
 					nullable: true, 
 					jsonbSchema: {
-						oneOfTypes: [
+						oneOf: [
 							{ ok: { type: "string" } },
 							{ err: { type: "string" } },
 							{ 
@@ -152,10 +152,10 @@ function dd(){
 				jsonOneOf: { 
 					nullable: true, 
 					jsonbSchema: { 
-						oneOfTypes: [
-							{ command: { oneOf: ["a"] } },
+						oneOf: [
+							{ command: { enum: ["a"] } },
 							{ 
-								command: { oneOf: ["b"] },
+								command: { enum: ["b"] },
 								option: { type: "integer[]" }
 							}
 						]

package/tests/server/package-lock.json

@@ -21,7 +21,7 @@
     },
     "../..": {
       "name": "prostgles-server",
-      "version": "2.0.332",
+      "version": "2.0.333",
       "license": "MIT",
       "dependencies": {
         "@aws-sdk/client-s3": "^3.121.0",

package/tests/server/server.ts

@@ -13,12 +13,12 @@ prostgles<DBSchemaGenerated>({
       columns: {
         id: { sqlDefinition: `SERIAL PRIMARY KEY ` },
         email: { sqlDefinition: `TEXT NOT NULL` },
-        status: { oneOf: ["active", "disabled", "pending"] },
+        status: { enum: ["active", "disabled", "pending"] },
         preferences: {
           defaultValue: "{}",
           jsonbSchema: {
             showIntro: { type: "boolean", optional: true },
-            theme: { oneOf: ["light", "dark"], optional: true },
+            theme: { enum: ["light", "dark"], optional: true },
           }
         },
       }