@snowtop/ent 0.1.27 → 0.2.0-alpha.10-test1

package/graphql/query/edge_connection.js

@@ -1,23 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLEdgeConnection = void 0;
+const query_1 = require("../../core/query");
 // TODO probably need to template Ent. maybe 2 ents?
 class GraphQLEdgeConnection {
     constructor(viewer, arg2, arg3, args) {
         this.results = [];
         this.viewer = viewer;
+        async function resolveQuery(query, source) {
+            const resolved = await query;
+            // To have pagination correctly work with CustomClauseQuery in GraphQL contexts, we need to
+            // pass the source to the query so that we can set the page info correctly
+            // See https://github.com/lolopinto/ent/issues/1836 for full details of how this breaks down
+            if (resolved instanceof query_1.CustomClauseQuery && source !== undefined) {
+                resolved.__maybeSetSource(source);
+            }
+            return resolved;
+        }
+        let query;
+        let source;
         if (typeof arg2 === "function") {
-            this.query = arg2(this.viewer);
+            query = arg2(this.viewer);
         }
         else {
             this.source = arg2;
+            source = arg2;
         }
         if (typeof arg3 === "function") {
-            this.query = arg3(this.viewer, this.source);
+            query = arg3(this.viewer, this.source);
         }
         else {
             this.args = arg3;
         }
+        this.query = Promise.resolve(resolveQuery(query, source));
         if (args !== undefined) {
             this.args = args;
         }
@@ -29,27 +44,31 @@ class GraphQLEdgeConnection {
                 throw new Error("cannot process before without last");
             }
             if (this.args.first) {
-                this.query = this.query.first(this.args.first, this.args.after);
+                const argFirst = this.args.first;
+                const argAfter = this.args.after;
+                this.query = this.query.then((query) => query.first(argFirst, argAfter));
             }
             if (this.args.last) {
-                this.query = this.query.last(this.args.last, this.args.cursor);
+                const argLast = this.args.last;
+                const argBefore = this.args.before;
+                this.query = this.query.then((query) => query.last(argLast, argBefore));
             }
             // TODO custom args
             // how to proceed
         }
     }
     first(limit, cursor) {
-        this.query = this.query.first(limit, cursor);
+        this.query = this.query.then((query) => query.first(limit, cursor));
     }
     last(limit, cursor) {
-        this.query = this.query.last(limit, cursor);
+        this.query = this.query.then((query) => query.last(limit, cursor));
     }
     // any custom filters can be applied here...
     modifyQuery(fn) {
-        this.query = fn(this.query);
+        this.query = this.query.then((query) => fn(query));
     }
     async queryTotalCount() {
-        return this.query.queryRawCount();
+        return (await this.query).queryRawCount();
     }
     async queryEdges() {
         // because of privacy, we need to query the node regardless of if the node is there
@@ -60,7 +79,7 @@ class GraphQLEdgeConnection {
     // if nodes queried just return ents
     // unlikely to query nodes and pageInfo so we just load this separately for now
     async queryNodes() {
-        return this.query.queryEnts();
+        return (await this.query).queryEnts();
     }
     defaultPageInfo() {
         return {
@@ -72,7 +91,7 @@ class GraphQLEdgeConnection {
     }
     async queryPageInfo() {
         await this.queryData();
-        const paginationInfo = this.query.paginationInfo();
+        const paginationInfo = (await this.query).paginationInfo();
         if (this.source !== undefined) {
             return paginationInfo.get(this.source.id) || this.defaultPageInfo();
         }
@@ -85,24 +104,25 @@ class GraphQLEdgeConnection {
         return this.defaultPageInfo();
     }
     async queryData() {
+        const query = await this.query;
         const [edges, ents] = await Promise.all([
             // TODO need a test that this will only fetch edges once
             // and then fetch ents afterward
-            this.query.queryEdges(),
-            this.query.queryEnts(),
+            query.queryEdges(),
+            query.queryEnts(),
         ]);
         let entsMap = new Map();
         ents.forEach((ent) => entsMap.set(ent.id, ent));
         let results = [];
         for (const edge of edges) {
-            const node = entsMap.get(this.query.dataToID(edge));
+            const node = entsMap.get(query.dataToID(edge));
             if (!node) {
                 continue;
             }
             results.push({
                 edge,
                 node,
-                cursor: this.query.getCursor(edge),
+                cursor: query.getCursor(edge),
             });
         }
         this.results = results;

package/graphql/query/shared_edge_connection.d.ts

@@ -1,6 +1,6 @@
-import { Viewer, Data, Ent } from "../../core/base";
-import { FakeContact } from "../../testutils/fake_data/index";
+import { Data, Ent, Viewer } from "../../core/base";
 import { EdgeQuery } from "../../core/query/query";
+import { FakeContact } from "../../testutils/fake_data/index";
 interface options<TEnt extends Ent, TEdge extends Data> {
     getQuery: (v: Viewer, src: Ent) => EdgeQuery<TEnt, Ent, TEdge>;
     tableName: string;

package/graphql/query/shared_edge_connection.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
-const viewer_1 = require("../../core/viewer");
+const query_1 = require("../../core/query");
 const ent_1 = require("../../core/ent");
-const edge_connection_1 = require("./edge_connection");
+const viewer_1 = require("../../core/viewer");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
+const edge_connection_1 = require("./edge_connection");
 class TestConnection {
     constructor(getQuery, ents, filter) {
         this.getQuery = getQuery;
@@ -18,10 +19,20 @@ class TestConnection {
         this.allContacts = this.allContacts.reverse();
         this.conn = new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(this.user.id), this.user, (v, user) => this.getQuery(v, user));
         if (this.filter) {
-            this.filter(this.conn, this.user, this.allContacts);
+            await this.filter(this.conn, this.user, this.allContacts);
         }
         this.filteredContacts = this.ents(this.allContacts);
     }
+    async testAsyncConn() {
+        const asyncConn = new edge_connection_1.GraphQLEdgeConnection(new viewer_1.IDViewer(this.user.id), this.user, (v, user) => new Promise((resolve) => {
+            setTimeout(() => resolve(this.getQuery(v, user)), 0);
+        }));
+        if (this.filter) {
+            await this.filter(asyncConn, this.user, this.allContacts);
+        }
+        const count = await asyncConn.queryTotalCount();
+        expect(count).toBe(test_helpers_1.inputs.length);
+    }
     async testTotalCount() {
         const count = await this.conn.queryTotalCount();
         expect(count).toBe(test_helpers_1.inputs.length);
@@ -39,7 +50,7 @@ class TestConnection {
         for (let i = 0; i < this.filteredContacts.length; i++) {
             const edge = edges[i];
             expect(edge.node.id).toBe(this.filteredContacts[i].id);
-            expect(this.conn.query.dataToID(edge.edge)).toBe(this.filteredContacts[i].id);
+            expect((await this.conn.query).dataToID(edge.edge)).toBe(this.filteredContacts[i].id);
         }
     }
 }
@@ -50,14 +61,16 @@ const commonTests = (opts) => {
             q instanceof index_1.UserToContactsFkeyQueryDeprecated ||
             q instanceof index_1.UserToContactsFkeyQueryAsc ||
             q instanceof index_1.UserToContactsFkeyQueryDeletedAt ||
-            q instanceof index_1.UserToContactsFkeyQueryDeletedAtAsc);
+            q instanceof index_1.UserToContactsFkeyQueryDeletedAtAsc ||
+            q instanceof query_1.CustomClauseQuery);
     }
     function getCursorFrom(q, contacts, idx) {
         let opts;
         if (isCustomQuery(q)) {
             opts = {
                 row: contacts[idx],
-                keys: ["id"],
+                cursorKeys: ["created_at", "id"],
+                rowKeys: ["createdAt", "id"],
             };
         }
         else {
@@ -65,8 +78,8 @@ const commonTests = (opts) => {
             // is from assoc_edge table id2 field and so cursor takes it from there
             opts = {
                 row: contacts[idx],
-                keys: ["id2"],
-                cursorKeys: ["id"],
+                cursorKeys: ["time", "id2"],
+                rowKeys: ["createdAt", "id"],
             };
         }
         return (0, ent_1.getCursor)(opts);
@@ -92,7 +105,7 @@ const commonTests = (opts) => {
         });
     });
     describe("filters. firstN", () => {
-        const filter = new TestConnection((v, user) => opts.getQuery(v, user), (contacts) => contacts.slice(0, 2), (conn) => {
+        const filter = new TestConnection((v, user) => opts.getQuery(v, user), (contacts) => contacts.slice(0, 2), async (conn) => {
             conn.first(2);
         });
         beforeEach(async () => {
@@ -124,8 +137,8 @@ const commonTests = (opts) => {
         const N = 3;
         const filter = new TestConnection((v, user) => opts.getQuery(v, user), 
         // get the next 2
-        (contacts) => contacts.slice(idx + 1, idx + N), (conn, user, contacts) => {
-            const cursor = getCursorFrom(conn.query, contacts, idx);
+        (contacts) => contacts.slice(idx + 1, idx + N), async (conn, user, contacts) => {
+            const cursor = getCursorFrom(await conn.query, contacts, idx);
             conn.first(2, cursor);
         });
         beforeEach(async () => {
@@ -153,9 +166,9 @@ const commonTests = (opts) => {
         });
     });
     describe("filters. before  cursor", () => {
-        const filter = new TestConnection((v, user) => opts.getQuery(v, user), (contacts) => contacts.slice(2, 4).reverse(), (conn, user, contacts) => {
+        const filter = new TestConnection((v, user) => opts.getQuery(v, user), (contacts) => contacts.slice(2, 4).reverse(), async (conn, user, contacts) => {
             // get the 2 before it
-            const cursor = getCursorFrom(conn.query, contacts, 4);
+            const cursor = getCursorFrom(await conn.query, contacts, 4);
             conn.last(2, cursor);
         });
         beforeEach(async () => {

package/names/names.d.ts

@@ -0,0 +1,10 @@
+export declare function toDBColumnOrTable(...strs: string[]): string;
+export declare function toFilePath(s: string): string;
+export declare function toFieldName(...strs: string[]): string;
+export declare function toClassName(str: string): string;
+interface splitResult {
+    s: string;
+    type: "lower" | "upper" | "digit" | "other";
+}
+export declare function _splitCamelCase(s: string): splitResult[];
+export {};

package/names/names.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._splitCamelCase = exports.toClassName = exports.toFieldName = exports.toFilePath = exports.toDBColumnOrTable = void 0;
+const camel_case_1 = require("camel-case");
+const pascal_case_1 = require("pascal-case");
+const snake_case_1 = require("snake-case");
+// TODO tests and update functionality to match golang
+function toDBColumnOrTable(...strs) {
+    let name = "";
+    for (let i = 0; i < strs.length; i++) {
+        const s = strs[i];
+        // this is to handle userIDs -> user_ids
+        const split = _splitCamelCase(s);
+        if (split.length > 2) {
+            const last = split[split.length - 1];
+            const nextLast = split[split.length - 2];
+            if (last.s === "s" && nextLast.type === "upper") {
+                // get the first n-2 words
+                name += (0, snake_case_1.snakeCase)(split
+                    .map((v) => v.s)
+                    .slice(0, split.length - 2)
+                    .join(""));
+                name += "_";
+                // combine the last two
+                name += (0, snake_case_1.snakeCase)(nextLast.s);
+                name += last.s;
+                continue;
+            }
+        }
+        name += (0, snake_case_1.snakeCase)(s);
+        if (i !== strs.length - 1) {
+            name += "_";
+        }
+    }
+    return name;
+}
+exports.toDBColumnOrTable = toDBColumnOrTable;
+function toFilePath(s) {
+    return (0, snake_case_1.snakeCase)(s);
+}
+exports.toFilePath = toFilePath;
+function toFieldName(...strs) {
+    let name = "";
+    let hasDoneLower = false;
+    for (const s of strs) {
+        // same logic in toDBColumnOrTable
+        const split = _splitCamelCase(s);
+        if (split.length > 2) {
+            const last = split[split.length - 1];
+            const nextLast = split[split.length - 2];
+            if (last.s === "s" && nextLast.type === "upper") {
+                // get the first n-2 words
+                name += (0, camel_case_1.camelCase)(split
+                    .map((v) => v.s)
+                    .slice(0, split.length - 2)
+                    .join(""));
+                // combine the last two
+                name += (0, pascal_case_1.pascalCase)(nextLast.s);
+                name += last.s;
+                hasDoneLower = true;
+                continue;
+            }
+        }
+        if (!hasDoneLower) {
+            name += (0, camel_case_1.camelCase)(s);
+            hasDoneLower = true;
+        }
+        else {
+            name += (0, pascal_case_1.pascalCase)(s);
+        }
+    }
+    return name;
+}
+exports.toFieldName = toFieldName;
+function toClassName(str) {
+    return (0, pascal_case_1.pascalCase)(str);
+}
+exports.toClassName = toClassName;
+function isUpper(s) {
+    for (const c of s) {
+        if (!(c >= "A" && c <= "Z")) {
+            return false;
+        }
+    }
+    return true;
+}
+function isLower(s) {
+    for (const c of s) {
+        if (!(c >= "a" && c <= "z")) {
+            return false;
+        }
+    }
+    return true;
+}
+function isDigit(s) {
+    return /^\d+$/.test(s);
+}
+// ported from golang in internal/names/names.go
+function _splitCamelCase(s) {
+    const results = [];
+    let lastType;
+    let type;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (isLower(c)) {
+            type = "lower";
+        }
+        else if (isUpper(c)) {
+            type = "upper";
+        }
+        else if (isDigit(c)) {
+            type = "digit";
+        }
+        else {
+            type = "other";
+        }
+        if (lastType == type) {
+            results[results.length - 1].s += c;
+        }
+        else {
+            results.push({ s: c, type });
+        }
+        lastType = type;
+    }
+    // this is for handling the userIDs -> "user", "ID", "s" case
+    const isPlural = function (curr, next) {
+        return curr.length > 1 && next === "s";
+    };
+    for (let i = 0; i < results.length - 1; i++) {
+        if (isUpper(results[i].s[0]) &&
+            isLower(results[i + 1].s[0]) &&
+            !isPlural(results[i].s, results[i + 1].s)) {
+            // get last item from results[i] and add to front of results[i+1]
+            results[i + 1].s =
+                results[i].s[results[i].s.length - 1] + results[i + 1].s;
+            // now has a prefix and is not all of one case
+            results[i + 1].type = "other";
+            // remove last character from results[i]
+            results[i].s = results[i].s.slice(0, results[i].s.length - 1);
+        }
+        else if (isDigit(results[i].s[0]) && isLower(results[i + 1].s[0])) {
+            results[i].s = results[i].s + results[i + 1].s;
+            results[i].type = "other";
+            // remove
+            results[i + 1].s = "";
+            i++;
+        }
+    }
+    for (let i = 0; i < results.length; i++) {
+        if (results[i].s === "") {
+            results.splice(i, 1);
+            i--;
+        }
+    }
+    return results;
+}
+exports._splitCamelCase = _splitCamelCase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.27",
+  "version": "0.2.0-alpha.10-test1",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/base_schema.js

@@ -37,12 +37,12 @@ let nodeField = (0, field_1.UUIDType)({
 });
 let nodeFields = {
     // inconsistent naming :(
-    ID: nodeField,
+    id: nodeField,
     ...tsFields,
 };
 let nodeFieldsWithTZ = {
     // inconsistent naming :(
-    ID: nodeField,
+    id: nodeField,
     createdAt: (0, field_1.TimestampType)({
         hideFromGraphQL: true,
         disableUserEditable: true,

package/schema/field.d.ts

@@ -100,7 +100,7 @@ interface PolymorphicStringOptions extends StringOptions {
 }
 export declare class PolymorphicStringField extends StringField {
     private opts;
-    private camelCaseVals;
+    private fieldNameValues;
     constructor(opts: PolymorphicStringOptions);
     validateWithFullData(val: any, b: Builder<any>): boolean;
     valid(val: any): boolean;

package/schema/field.js

@@ -25,7 +25,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUIDListType = exports.IntegerEnumListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.IntegerEnumType = exports.IntegerEnumField = exports.EnumType = exports.StringEnumField = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.PolymorphicStringField = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.NumberField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
-const camel_case_1 = require("camel-case");
 const types_1 = require("util/types");
 const uuid_1 = require("uuid");
 const base_1 = require("../core/base");
@@ -33,6 +32,7 @@ const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
 const global_schema_1 = require("../core/global_schema");
 const logger_1 = require("../core/logger");
+const names_1 = require("../names/names");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -57,6 +57,7 @@ class UUIDField extends BaseField {
         const polymorphic = this.options?.polymorphic;
         if (polymorphic) {
             let name = "";
+            // TODO followup to https://github.com/lolopinto/ent/pull/1757
             if (fieldName.endsWith("_id")) {
                 let idx = fieldName.indexOf("_id");
                 name = fieldName.substring(0, idx) + "_type";
@@ -328,7 +329,7 @@ class PolymorphicStringField extends StringField {
         super(opts);
         this.opts = opts;
         if (opts.types) {
-            this.camelCaseVals = opts.types.map((v) => (0, camel_case_1.camelCase)(v));
+            this.fieldNameValues = opts.types.map((v) => (0, names_1.toFieldName)(v));
         }
     }
     validateWithFullData(val, b) {
@@ -347,19 +348,19 @@ class PolymorphicStringField extends StringField {
         return true;
     }
     valid(val) {
-        if (!this.camelCaseVals) {
+        if (!this.fieldNameValues) {
             return true;
         }
-        let str = (0, camel_case_1.camelCase)(String(val));
+        let str = (0, names_1.toFieldName)(String(val));
         // allow different cases because it could be coming from different clients who don't have strong typing
-        return this.camelCaseVals.some((value) => value === str);
+        return this.fieldNameValues.some((value) => value === str);
     }
     format(val) {
-        if (!this.camelCaseVals) {
+        if (!this.fieldNameValues) {
             return val;
         }
-        const converted = (0, camel_case_1.camelCase)(String(val));
-        for (const v of this.camelCaseVals) {
+        const converted = (0, names_1.toFieldName)(String(val));
+        for (const v of this.fieldNameValues) {
             if (v === val) {
                 return val;
             }

package/schema/schema.d.ts

@@ -247,6 +247,7 @@ export interface FieldOptions {
     getDerivedFields?(name: string): FieldMap;
     convert?: ConvertType;
     fetchOnDemand?: boolean;
+    disableBase64Encode?: boolean;
     dbOnly?: boolean;
     [x: string]: any;
 }
@@ -271,9 +272,6 @@ export interface SchemaConstructor {
 export type SchemaInputType = Schema | SchemaConstructor;
 export declare function getSchema(value: SchemaInputType): Schema;
 export declare function getFields(value: SchemaInputType): Map<string, Field>;
-/**
- * @deprecated should only be used by tests
- */
 export declare function getStorageKey(field: Field, fieldName: string): string;
 export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldInfoMap: FieldInfoMap): Map<string, PrivacyPolicy>;
 export declare function getFieldsWithEditPrivacy(value: SchemaInputType, fieldInfoMap: FieldInfoMap): Map<string, PrivacyPolicy>;

package/schema/schema.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsForCreateAction = exports.getFieldsWithEditPrivacy = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
-const snake_case_1 = require("snake-case");
+const names_1 = require("../names/names");
 // we also want this transformation to exist on a per-action basis
 // if it exists on an action, we don't do the global schema transformation
 var SQLStatementOperation;
@@ -79,11 +79,8 @@ function getFields(value) {
     return m;
 }
 exports.getFields = getFields;
-/**
- * @deprecated should only be used by tests
- */
 function getStorageKey(field, fieldName) {
-    return field.storageKey || (0, snake_case_1.snakeCase)(fieldName);
+    return field.storageKey || (0, names_1.toDBColumnOrTable)(fieldName);
 }
 exports.getStorageKey = getStorageKey;
 // returns a mapping of storage key to field privacy

package/schema/struct_field.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StructTypeAsList = exports.StructListType = exports.StructType = exports.StructField = void 0;
-const camel_case_1 = require("camel-case");
 const field_1 = require("./field");
 const schema_1 = require("./schema");
 const global_schema_1 = require("../core/global_schema");
 const logger_1 = require("../core/logger");
+const names_1 = require("../names/names");
 class StructField extends field_1.BaseField {
     constructor(options, jsonAsList) {
         super();
@@ -40,10 +40,14 @@ class StructField extends field_1.BaseField {
             const field = this.options.fields[k];
             // check two values
             // store in dbKey format
-            // TODO more #510
+            // check both fieldName and dbKey and store in dbKey for
+            // serialization to db
+            // we should only have if it in fieldName format for non-tests
+            // but checking for backwards compatibility and to make
+            // sure we don't break anything
             let dbKey = (0, schema_1.getStorageKey)(field, k);
-            let camelKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[camelKey];
+            let fieldName = (0, names_1.toFieldName)(k);
+            let val = obj[fieldName];
             if (val === undefined && obj[dbKey] !== undefined) {
                 val = obj[dbKey];
             }
@@ -114,20 +118,19 @@ class StructField extends field_1.BaseField {
         let valid = true;
         for (const k in this.options.fields) {
             const field = this.options.fields[k];
-            // TODO more #510
             let dbKey = (0, schema_1.getStorageKey)(field, k);
-            let camelKey = (0, camel_case_1.camelCase)(k);
-            let val = obj[camelKey];
+            let fieldName = (0, names_1.toFieldName)(k);
+            let val = obj[fieldName];
             let uniqueKeyField = false;
             if (this.validateUniqueKey !== undefined &&
-                (camelKey === this.validateUniqueKey ||
+                (fieldName === this.validateUniqueKey ||
                     k === this.validateUniqueKey ||
                     dbKey === this.validateUniqueKey)) {
                 // this.validateUniqueKey = camelKey;
                 uniqueKeyField = true;
             }
             if (uniqueKeyField && this.checkUniqueKey) {
-                this.validateUniqueKey = camelKey;
+                this.validateUniqueKey = fieldName;
             }
             if (val === undefined && obj[dbKey] !== undefined) {
                 if (uniqueKeyField && this.checkUniqueKey) {

package/scripts/read_schema.js

@@ -28,10 +28,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const glob = __importStar(require("glob"));
 const path = __importStar(require("path"));
-const pascal_case_1 = require("pascal-case");
 const minimist_1 = __importDefault(require("minimist"));
 const parse_1 = require("../parse_schema/parse");
 const ast_1 = require("../tsc/ast");
+const names_1 = require("../names/names");
 function main() {
     const options = (0, minimist_1.default)(process.argv.slice(2));
     if (!options.path) {
@@ -70,7 +70,7 @@ function main() {
         if (relativePath !== undefined) {
             s.schemaPath = relativePath;
         }
-        potentialSchemas[(0, pascal_case_1.pascalCase)(schema)] = s;
+        potentialSchemas[(0, names_1.toClassName)(schema)] = s;
     }
     //  console.log(potentialSchemas);
     // NB: do not change this to async/await