@snowtop/ent 0.1.22 → 0.1.24

package/core/base.d.ts

@@ -70,6 +70,7 @@ export interface SelectBaseDataOptions extends DataOptions {
     fields: string[];
     fieldsAlias?: string;
     disableFieldsAlias?: boolean;
+    disableDefaultOrderByAlias?: boolean;
 }
 export interface SelectDataOptions extends SelectBaseDataOptions {
     key: string;

package/core/query_impl.d.ts

@@ -2,6 +2,7 @@ import { QueryableDataOptions } from "./base";
 export interface OrderByOption {
     column: string;
     direction: "ASC" | "DESC";
+    alias?: string;
     nullsPlacement?: "first" | "last";
     dateColumn?: boolean;
 }

package/core/query_impl.js

@@ -13,7 +13,8 @@ function getOrderByPhrase(orderby, alias) {
                 nullsPlacement = " NULLS LAST";
                 break;
         }
-        const col = alias ? `${alias}.${v.column}` : v.column;
+        const orderByAlias = v.alias ?? alias;
+        const col = orderByAlias ? `${orderByAlias}.${v.column}` : v.column;
         return `${col} ${v.direction}${nullsPlacement}`;
     })
         .join(", ");
@@ -71,7 +72,7 @@ function buildQuery(options) {
         parts.push(`GROUP BY ${options.groupby}`);
     }
     if (options.orderby) {
-        parts.push(`ORDER BY ${getOrderByPhrase(options.orderby, fieldsAlias)}`);
+        parts.push(`ORDER BY ${getOrderByPhrase(options.orderby, options.disableDefaultOrderByAlias ? undefined : fieldsAlias)}`);
     }
     if (options.limit) {
         parts.push(`LIMIT ${options.limit}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.js

@@ -180,22 +180,126 @@ async function processPattern(patterns, pattern, processedSchema) {
             }
         }
     }
-    if (patterns[name] === undefined) {
+    if (!patterns.hasPattern(name)) {
         // intentionally processing separately and not passing pattern.name
         const edges = processEdges(pattern.edges || []);
-        patterns[name] = {
+        const processed = {
             name: pattern.name,
             assocEdges: edges,
             fields: fields,
             disableMixin: pattern.disableMixin,
         };
+        patterns.addPattern(pattern, processed);
     }
     else {
-        // TODO ideally we want to make sure that different patterns don't have the same name
         // can't do a deepEqual check because function calls and therefore different instances in fields
+        // so compare as best we can
+        const cmp = comparePatterns(pattern, patterns);
+        if (typeof cmp !== "boolean") {
+            if (cmp.field) {
+                throw new Error(`pattern '${pattern.name}' in schema ${processedSchema.schemaPath} has different field ${cmp.field.name} from another pattern with the same name`);
+            }
+            else if (cmp.edge) {
+                throw new Error(`pattern '${pattern.name}' in schema ${processedSchema.schemaPath} has different field ${cmp.edge.name} from another pattern with the same name`);
+            }
+            else {
+                throw new Error(`pattern '${pattern.name}' in schema ${processedSchema.schemaPath} has different ${cmp.difference} from another pattern with the same name`);
+            }
+        }
     }
     return ret;
 }
+function comparePatterns(pattern, patterns) {
+    const processedPattern = patterns.getProcessedPattern(pattern.name);
+    if (pattern.name !== processedPattern.name) {
+        return {
+            difference: "name",
+        };
+    }
+    if (pattern.disableMixin !== processedPattern.disableMixin) {
+        return {
+            difference: "disableMixin",
+        };
+    }
+    const processedFields = patterns.getPatternFields(pattern.name);
+    for (const k in pattern.fields) {
+        if (!processedFields[k]) {
+            return {
+                difference: "field",
+                field: {
+                    name: k,
+                },
+            };
+        }
+        if (!compareField(pattern.fields[k], processedFields[k])) {
+            return {
+                difference: "field",
+                field: {
+                    name: k,
+                },
+            };
+        }
+    }
+    for (const k in processedFields) {
+        if (!pattern.fields[k]) {
+            return {
+                difference: "field",
+                field: {
+                    name: k,
+                },
+            };
+        }
+    }
+    if ((pattern.edges?.length ?? 0) !== (processedPattern.assocEdges.length ?? 0)) {
+        return {
+            difference: "edges",
+        };
+    }
+    if (!pattern.edges?.length) {
+        return true;
+    }
+    for (let i = 0; i < pattern.edges?.length; i++) {
+        if (!compareEdge(pattern.edges[i], processedPattern.assocEdges[i])) {
+            return {
+                difference: "edge",
+                edge: {
+                    name: pattern.edges[i].name,
+                },
+            };
+        }
+    }
+    return true;
+}
+function compareObject(o1, o2) {
+    for (const k in o1) {
+        const v = o1[k];
+        if (typeof v === "function" ||
+            typeof v === "symbol" ||
+            (typeof v === "object" && v !== null)) {
+            continue;
+        }
+        if (v !== o2[k]) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareField(field, procesedField) {
+    for (const k in field) {
+        if (!compareObject(field[k], procesedField[k])) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareEdge(edge, processedEdge) {
+    for (const k in edge) {
+        if (!compareObject(edge[k], processedEdge[k])) {
+            return false;
+        }
+    }
+    return true;
+}
 var NullableResult;
 (function (NullableResult) {
     NullableResult["CONTENTS"] = "contents";
@@ -238,9 +342,36 @@ function processAction(action) {
     }
     return ret;
 }
+class ProcessPatterns {
+    constructor() {
+        this.patternsDict = {};
+        this.originalPatterns = {};
+    }
+    addPattern(pattern, processed) {
+        this.originalPatterns[pattern.name] = pattern;
+        this.patternsDict[pattern.name] = processed;
+    }
+    getProcessedPattern(name) {
+        const pattern = this.patternsDict[name];
+        if (!pattern) {
+            throw new Error(`no pattern ${name}`);
+        }
+        return pattern;
+    }
+    getPatternFields(name) {
+        const pattern = this.originalPatterns[name];
+        if (!pattern) {
+            throw new Error(`no pattern ${name}`);
+        }
+        return pattern.fields;
+    }
+    hasPattern(name) {
+        return !!this.patternsDict[name];
+    }
+}
 async function parseSchema(potentialSchemas, globalSchema) {
-    let schemas = {};
-    let patterns = {};
+    const schemas = {};
+    const processPatterns = new ProcessPatterns();
     let parsedGlobalSchema;
     if (globalSchema) {
         parsedGlobalSchema = await parseGlobalSchema(globalSchema);
@@ -285,7 +416,7 @@ async function parseSchema(potentialSchemas, globalSchema) {
         let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                const ret = await processPattern(patterns, pattern, processedSchema);
+                const ret = await processPattern(processPatterns, pattern, processedSchema);
                 patternNames.push(pattern.name);
                 if (ret.transformsSelect) {
                     if (processedSchema.transformsSelect) {
@@ -320,7 +451,7 @@ async function parseSchema(potentialSchemas, globalSchema) {
     const biome = translatePrettier();
     return {
         schemas,
-        patterns,
+        patterns: processPatterns.patternsDict,
         globalSchema: parsedGlobalSchema,
         config: {
             rome: biome,

package/schema/struct_field.js

@@ -92,7 +92,8 @@ class StructField extends field_1.BaseField {
                     }
                 }
                 // TODO handle format code
-                return f.format(obj);
+                // ola 1/20/24 don't know what this TODO means lol
+                return f.format(obj, nested);
             }
         }
         if (Array.isArray(obj) && this.jsonAsList) {