@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha60

package/core/base.js

@@ -30,7 +30,23 @@ function Deny() {
     return deny;
 }
 exports.Deny = Deny;
+class DenyWithReasonError extends Error {
+    constructor(privacyPolicy, rule, msg, ent) {
+        super(msg);
+        this.privacyPolicy = privacyPolicy;
+        this.privacyRule = rule;
+        this.ent = ent;
+    }
+}
 function DenyWithReason(e) {
+    if (typeof e === "string") {
+        return {
+            result: privacyResult.Deny,
+            getError(policy, rule, ent) {
+                return new DenyWithReasonError(policy, rule, e, ent);
+            },
+        };
+    }
     return {
         result: privacyResult.Deny,
         error: e,

package/core/clause.d.ts

@@ -1,5 +1,6 @@
 export interface Clause {
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
@@ -12,8 +13,11 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    constructor(col: string, value: any, op: string);
+    private handleNull?;
+    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
     clause(idx: number): string;
+    private nullClause;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -23,18 +27,64 @@ declare class compositeClause implements Clause {
     private sep;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
-export declare function Eq(col: string, value: any): simpleClause;
-export declare function NotEq(col: string, value: any): simpleClause;
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContains(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContains(col: string, value: any[]): Clause;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
+export declare function ArrayEq(col: string, value: any): Clause;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
+export declare function ArrayNotEq(col: string, value: any): Clause;
+export declare function Eq(col: string, value: any): Clause;
+export declare function NotEq(col: string, value: any): Clause;
 export declare function Greater(col: string, value: any): simpleClause;
 export declare function Less(col: string, value: any): simpleClause;
 export declare function GreaterEq(col: string, value: any): simpleClause;
 export declare function LessEq(col: string, value: any): simpleClause;
 export declare function And(...args: Clause[]): compositeClause;
+export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
 export declare function Or(...args: Clause[]): compositeClause;
 export declare function In(col: string, ...values: any): Clause;
+interface TsQuery {
+    language: "english" | "french" | "german" | "simple";
+    value: string;
+}
+export declare function TsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function PhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function WebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorColTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
+export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function sensitiveValue(val: any): SensitiveValue;
 export {};

package/core/clause.js

@@ -19,10 +19,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = void 0;
+exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
-    return (typeof val === "object" && val.logValue !== undefined);
+    return (val !== null &&
+        typeof val === "object" &&
+        val.logValue !== undefined);
 }
 function rawValue(val) {
     if (isSensitive(val)) {
@@ -31,33 +33,184 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
+        this.handleNull = handleNull;
     }
     clause(idx) {
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.clause(idx);
+        }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
+            return;
+        }
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
+    }
     values() {
+        const sqliteClause = this.nullClause();
+        if (sqliteClause) {
+            return sqliteClause.values();
+        }
         if (isSensitive(this.value)) {
             return [this.value.value()];
         }
         return [this.value];
     }
     logValues() {
+        const sqliteClause = this.nullClause();
+        if (sqliteClause) {
+            return sqliteClause.logValues();
+        }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
         }
         return [this.value];
     }
     instanceKey() {
+        const sqliteClause = this.nullClause();
+        if (sqliteClause) {
+            return sqliteClause.instanceKey();
+        }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class isNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NULL`;
+    }
+    columns() {
+        return [];
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NULL`;
+    }
+}
+class isNotNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NOT NULL`;
+    }
+    columns() {
+        return [];
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NOT NULL`;
+    }
+}
+class arraySimpleClause {
+    constructor(col, value, op) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            return `$${idx} ${this.op} ANY(${this.col})`;
+        }
+        return `${this.col} ${this.op} ?`;
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [this.value.value()];
+        }
+        return [this.value];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.value.logValue()];
+        }
+        return [this.value];
+    }
+    instanceKey() {
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
+class postgresArrayContains {
+    constructor(col, value, not) {
+        this.col = col;
+        this.value = value;
+        this.not = not;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            if (this.not) {
+                return `NOT ${this.col} @> $${idx}`;
+            }
+            return `${this.col} @> $${idx}`;
+        }
+        throw new Error(`not supported`);
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.value()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.value.logValue()];
+        }
+        return [this.value];
+    }
+    instanceKey() {
+        if (this.not) {
+            return `NOT:${this.col}@>${rawValue(this.value)}`;
+        }
+        return `${this.col}@>${rawValue(this.value)}`;
+    }
+}
+class postgresArrayContainsList extends postgresArrayContains {
+    constructor(col, value, not) {
+        super(col, value, not);
+    }
+    values() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.value();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+}
 class inClause {
     constructor(col, value) {
         this.col = col;
@@ -84,6 +237,9 @@ class inClause {
         // or change to a sqlx.Rebind format
         // here's what sqlx does: https://play.golang.org/p/vPzvYqeAcP0
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const result = [];
         for (const value of this.value) {
@@ -125,6 +281,13 @@ class compositeClause {
         }
         return clauses.join(this.sep);
     }
+    columns() {
+        const ret = [];
+        for (const cls of this.clauses) {
+            ret.push(...cls.columns());
+        }
+        return ret;
+    }
     values() {
         let result = [];
         for (const clause of this.clauses) {
@@ -145,12 +308,128 @@ class compositeClause {
         return keys.join(this.sep);
     }
 }
+class tsQueryClause {
+    constructor(col, val, tsVectorCol) {
+        this.col = col;
+        this.val = val;
+        this.tsVectorCol = tsVectorCol;
+    }
+    isTsQuery(val) {
+        return typeof val !== "string";
+    }
+    getInfo() {
+        if (this.isTsQuery(this.val)) {
+            return { value: this.val.value, language: this.val.language };
+        }
+        return {
+            language: "english",
+            value: this.val,
+        };
+    }
+    clause(idx) {
+        const { language } = this.getInfo();
+        if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
+            if (this.tsVectorCol) {
+                return `to_tsvector(${this.col}) @@ ${this.getFunction()}('${language}', $${idx})`;
+            }
+            return `${this.col} @@ ${this.getFunction()}('${language}', $${idx})`;
+        }
+        // FYI this doesn't actually work for sqlite since different
+        return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    logValues() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    getFunction() {
+        return "to_tsquery";
+    }
+    instanceKey() {
+        const { language, value } = this.getInfo();
+        if (this.tsVectorCol) {
+            return `to_tsvector(${this.col})@@${this.getFunction()}:${language}:${value}`;
+        }
+        return `${this.col}@@${this.getFunction()}:${language}:${value}`;
+    }
+}
+class plainToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "plainto_tsquery";
+    }
+}
+class phraseToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "phraseto_tsquery";
+    }
+}
+class websearchTosQueryClause extends tsQueryClause {
+    getFunction() {
+        return "websearch_to_tsquery";
+    }
+}
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContainsValue(col, value) {
+    return new postgresArrayContains(col, value);
+}
+exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContains(col, value) {
+    return new postgresArrayContainsList(col, value);
+}
+exports.PostgresArrayContains = PostgresArrayContains;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContainsValue(col, value) {
+    return new postgresArrayContains(col, value, true);
+}
+exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContains(col, value) {
+    return new postgresArrayContainsList(col, value, true);
+}
+exports.PostgresArrayNotContains = PostgresArrayNotContains;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
+function ArrayEq(col, value) {
+    return new arraySimpleClause(col, value, "=");
+}
+exports.ArrayEq = ArrayEq;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
+function ArrayNotEq(col, value) {
+    return new arraySimpleClause(col, value, "!=");
+}
+exports.ArrayNotEq = ArrayNotEq;
 function Eq(col, value) {
-    return new simpleClause(col, value, "=");
+    return new simpleClause(col, value, "=", new isNullClause(col));
 }
 exports.Eq = Eq;
 function NotEq(col, value) {
-    return new simpleClause(col, value, "!=");
+    return new simpleClause(col, value, "!=", new isNotNullClause(col));
 }
 exports.NotEq = NotEq;
 function Greater(col, value) {
@@ -173,6 +452,15 @@ function And(...args) {
     return new compositeClause(args, " AND ");
 }
 exports.And = And;
+function AndOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return And(...filtered);
+}
+exports.AndOptional = AndOptional;
 function Or(...args) {
     return new compositeClause(args, " OR ");
 }
@@ -182,6 +470,60 @@ function In(col, ...values) {
     return new inClause(col, values);
 }
 exports.In = In;
+// if string defaults to english
+// https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+// to_tsquery
+// plainto_tsquery
+// phraseto_tsquery;
+// websearch_to_tsquery
+function TsQuery(col, val) {
+    return new tsQueryClause(col, val);
+}
+exports.TsQuery = TsQuery;
+function PlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val);
+}
+exports.PlainToTsQuery = PlainToTsQuery;
+function PhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val);
+}
+exports.PhraseToTsQuery = PhraseToTsQuery;
+function WebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val);
+}
+exports.WebsearchToTsQuery = WebsearchToTsQuery;
+// TsVectorColTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorColTsQuery(col, val) {
+    return new tsQueryClause(col, val, true);
+}
+exports.TsVectorColTsQuery = TsVectorColTsQuery;
+// TsVectorPlainToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+// TODO do these 4 need TsQuery because would be nice to have language?
+// it seems to default to the config of the column
+function TsVectorPlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val, true);
+}
+exports.TsVectorPlainToTsQuery = TsVectorPlainToTsQuery;
+// TsVectorPhraseToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorPhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val, true);
+}
+exports.TsVectorPhraseToTsQuery = TsVectorPhraseToTsQuery;
+// TsVectorWebsearchToTsQuery is used when the column is not a tsvector field e.g.
+// when there's an index just on the field and is not a combination of multiple fields
+function TsVectorWebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val, true);
+}
+exports.TsVectorWebsearchToTsQuery = TsVectorWebsearchToTsQuery;
+// TODO would be nice to support this with building blocks but not supporting for now
+// AND: foo & bar,
+// OR: foo | bar
+// followed by: foo <-> bar
+// NOT: !foo
+// starts_with: theo:*
 // wrap a query in the db with this to ensure that it doesn't show up in the logs
 // e.g. if querying for password, SSN, etc
 // we'll pass the right fields to query and log something along the lines of `****`

package/core/config.d.ts

@@ -1,12 +1,26 @@
 /// <reference types="node" />
 import { Database, DBDict } from "./db";
 declare type logType = "query" | "warn" | "info" | "error" | "debug";
+declare enum graphqlMutationName {
+    NOUN_VERB = "NounVerb",
+    VERB_NOUN = "VerbNoun"
+}
+declare enum graphQLFieldFormat {
+    LOWER_CAMEL = "lowerCamel",
+    SNAKE_CASE = "snake_case"
+}
+declare enum fieldPrivacyEvaluated {
+    AT_ENT_LOAD = "at_ent_load",
+    ON_DEMAND = "on_demand"
+}
 export interface Config {
     dbConnectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
     log?: logType | logType[];
     codegen?: CodegenConfig;
+    customGraphQLJSONPath?: string;
+    globalSchemaPath?: string;
 }
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
@@ -17,6 +31,13 @@ interface CodegenConfig {
     generatedHeader?: string;
     disableBase64Encoding?: boolean;
     generateRootResolvers?: boolean;
+    defaultGraphQLMutationName?: graphqlMutationName;
+    defaultGraphQLFieldFormat?: graphQLFieldFormat;
+    schemaSQLFilePath?: boolean;
+    databaseToCompareTo?: string;
+    fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
+    templatizedViewer?: importedObject;
+    customAssocEdgePath?: importedObject;
 }
 interface PrettierConfig {
     custom?: boolean;
@@ -27,5 +48,10 @@ interface PrivacyConfig {
     policyName: string;
     class?: boolean;
 }
+interface importedObject {
+    path: string;
+    name: string;
+    alias?: string;
+}
 export declare function loadConfig(file?: string | Buffer | Config): void;
 export {};

package/core/config.js

@@ -28,6 +28,23 @@ const js_yaml_1 = require("js-yaml");
 const db_1 = __importDefault(require("./db"));
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
+// ent.config.ts eventually. for now ent.yml
+// or ent.yml?
+var graphqlMutationName;
+(function (graphqlMutationName) {
+    graphqlMutationName["NOUN_VERB"] = "NounVerb";
+    graphqlMutationName["VERB_NOUN"] = "VerbNoun";
+})(graphqlMutationName || (graphqlMutationName = {}));
+var graphQLFieldFormat;
+(function (graphQLFieldFormat) {
+    graphQLFieldFormat["LOWER_CAMEL"] = "lowerCamel";
+    graphQLFieldFormat["SNAKE_CASE"] = "snake_case";
+})(graphQLFieldFormat || (graphQLFieldFormat = {}));
+var fieldPrivacyEvaluated;
+(function (fieldPrivacyEvaluated) {
+    fieldPrivacyEvaluated["AT_ENT_LOAD"] = "at_ent_load";
+    fieldPrivacyEvaluated["ON_DEMAND"] = "on_demand";
+})(fieldPrivacyEvaluated || (fieldPrivacyEvaluated = {}));
 function setConfig(cfg) {
     if (cfg.log) {
         (0, logger_1.setLogLevels)(cfg.log);

package/core/context.d.ts

@@ -3,8 +3,8 @@ import { Viewer, Data, Loader } from "./base";
 import { IncomingMessage, ServerResponse } from "http";
 import * as clause from "./clause";
 import { Context } from "./base";
-export interface RequestContext extends Context {
-    authViewer(viewer: Viewer): Promise<void>;
+export interface RequestContext<TViewer extends Viewer = Viewer> extends Context<TViewer> {
+    authViewer(viewer: TViewer): Promise<void>;
     logout(): Promise<void>;
     request: IncomingMessage;
     response: ServerResponse;

package/core/context.js

@@ -39,7 +39,7 @@ class ContextCache {
         const key = this.getkey(options);
         let rows = m.get(key);
         if (rows) {
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });
@@ -54,7 +54,7 @@ class ContextCache {
         const key = this.getkey(options);
         let row = m.get(key);
         if (row) {
-            (0, logger_1.log)("query", {
+            (0, logger_1.log)("cache", {
                 "cache-hit": key,
                 "tableName": options.tableName,
             });

package/core/convert.d.ts

@@ -10,5 +10,5 @@ export declare function convertBoolList(val: any): boolean[];
 export declare function convertNullableBoolList(val: any): boolean[] | null;
 export declare function convertJSON(val: any): any;
 export declare function convertNullableJSON(val: any): any | null;
-export declare function convertJSONList(val: any): boolean[];
+export declare function convertJSONList(val: any): any[];
 export declare function convertNullableJSONList(val: any): any[] | null;

package/core/db.d.ts

@@ -1,11 +1,10 @@
-import { Pool, ClientConfig, PoolClient } from "pg";
-export interface Database {
+import { Pool, PoolClient, PoolConfig } from "pg";
+export interface Database extends PoolConfig {
     database?: string;
     user?: string;
     password?: string;
     host?: string;
     port?: number;
-    ssl?: boolean;
     sslmode?: string;
 }
 export declare type env = "production" | "test" | "development";
@@ -16,7 +15,7 @@ export declare enum Dialect {
 }
 interface DatabaseInfo {
     dialect: Dialect;
-    config: ClientConfig;
+    config: PoolConfig;
     filePath?: string;
 }
 export default class DB {

package/core/db.js

@@ -109,6 +109,8 @@ function getClientConfig(args) {
                     host: cfg.host,
                     port: cfg.port,
                     ssl: cfg.sslmode == "enable",
+                    // max, min, etc
+                    ...cfg,
                 },
             };
         }