prostgles-server 2.0.333 → 2.0.335

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,120 +174,160 @@ 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){
-      const { type } = itemSchema;
-      /**
-       * Is primitive or any
-       */
-      if(typeof type === "string"){
-        const arrayType = type.endsWith("[]")? type.slice(0, -2) : undefined;
-        if(arrayType){
-          item = {
-            type: "array",
-            items: { type: arrayType === "any"? {} : arrayType }
+namespace JSTypes {
+  type Base = {
+    $id?: string;
+    $schema?: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    // nullable?: boolean;
+    // optional?: boolean;
+  }
+  export type Any = {};
+
+  export type Object = Base & {
+    type: "object";
+    properties: Record<string, Schema>;
+  }
+  export type Enum = Base & {
+    type: "string" | "number";
+    enum: (string | number)[]
+  }
+  export type Array = Base & {
+    type: "array";
+    items: (string | number)[]
+  }
+  export type OneOf = {
+    oneOf: (Any | Object | Enum | Array)[]
+  }
+  export type Schema = 
+  | Any
+  | Object
+  | Enum
+  | Array
+  | OneOf;
+}
+
+type JSONSchema = JSTypes.Schema
+
+const getJSONSchemaObject = <T extends ValidationSchema>(objDef: T): Record<keyof T, JSONSchema> => {
+  const resultType: JSONSchema = {
+    type: "object",
+    properties: getKeys(objDef).reduce((a, k) => {
+      const itemSchema: FieldType = objDef[k];
+      const { nullable, optional, description, title } = itemSchema;
+      let item = {} as any;
+
+      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) {
+            item = {
+              type: "array",
+              items: { type: arrayType === "any" ? {} : arrayType }
+            }
+          } else {
+            item = {
+              type: type === "any" ? {} : type
+            }
           }
+
+          /**
+           * Is object
+           */
         } else {
           item = {
-            type: type === "any"? {} : type
+            type: "object",
+            properties: getJSONSchemaObject(type)
           }
+
         }
 
-      /**
-       * Is object
-       */
-      } else {
+      } else if ("enum" in itemSchema) {
         item = {
-          type: "object",
-          properties: getJSONSchemaObject(type)
+          type: typeof itemSchema.enum[0]!,
+          "enum": itemSchema.enum //.concat(nullable? [null] : [])
         }
-
+      } else if ("oneOf" in itemSchema) {
+        item = {
+          oneOf: itemSchema.oneOf.map(t => getJSONSchemaObject(t))
+        }
+      } else {
+        throw new Error("Unexpected jsonbSchema itemSchema" + JSON.stringify({ itemSchema, objDef }, null, 2))
       }
 
-    } else if("oneOf" in itemSchema) {
-      item = { 
-        type: typeof itemSchema.oneOf[0]!,
-        "enum": itemSchema.oneOf //.concat(nullable? [null] : [])
-      }
-    } else if("oneOfTypes" in itemSchema) {
-      item = {
-        oneOf: itemSchema.oneOfTypes.map(t => getJSONSchemaObject(t))
+      if (nullable) {
+        const nullDef = { type: "null" }
+        if (item.oneOf) item.oneOf.push(nullDef)
+        else item = {
+          oneOf: [item, nullDef]
+        }
       }
-    } else {
-      throw new Error("Unexpected jsonbSchema itemSchema" + JSON.stringify({itemSchema, objDef}, null, 2))
-    }
 
-    if(nullable){
-      const nullDef = { type: "null" }
-      if(item.oneOf) item.oneOf.push(nullDef)
-      else item = {
-        oneOf: [item, nullDef]
+      return {
+        ...a,
+        [k]: {
+          ...item,
+          required: !optional,
+          description,
+          title,
+        }
       }
-    }
+    }, {} as Record<string, JSTypes.Schema>)
+  }
 
-    return { 
-      ...a,
-      [k]: {
-        ...item,
-        required: !optional,
-        description, 
-        title,
-      }
-    }
-  }, resultType)
+  return resultType as any;
 }
 
-export function getJSONBSchemaAsJSONSchema(tableName: string, colName: string, columnConfig: BaseColumn<{ en: 1 }> & JSONBColumnDef): AnyObject {
+export function getJSONBSchemaAsJSONSchema(tableName: string, colName: string, columnConfig: BaseColumn<{ en: 1 }> & JSONBColumnDef): JSONSchema {
 
   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 :
+      { 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.335",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/client/PID.txt

@@ -1 +1 @@
-70976
+81428

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.334",
       "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 },
           }
         },
       }