true-pg 0.2.2 → 0.3.0

package/lib/extractor/pgtype.d.ts

@@ -0,0 +1,41 @@
+export declare const typeKindMap: {
+    readonly d: "domain";
+    readonly e: "enum";
+    readonly r: "range";
+};
+type TypeKind = (typeof typeKindMap)[keyof typeof typeKindMap];
+export declare const classKindMap: {
+    readonly r: "table";
+    readonly p: "table";
+    readonly v: "view";
+    readonly m: "materializedView";
+    readonly c: "composite";
+};
+type ClassKind = (typeof classKindMap)[keyof typeof classKindMap];
+export declare const routineKindMap: {
+    readonly f: "function";
+};
+type RoutineKind = (typeof routineKindMap)[keyof typeof routineKindMap];
+export type Kind = TypeKind | ClassKind | RoutineKind;
+/**
+ * Base type for Postgres objects.
+ */
+export type PgType<K extends Kind = Kind> = {
+    /**
+     * The name of the object.
+     */
+    name: string;
+    /**
+     * The name of the schema that the object is in.
+     */
+    schemaName: string;
+    /**
+     * The kind of the object.
+     */
+    kind: K;
+    /**
+     * The comment on the object, if any.
+     */
+    comment: string | null;
+};
+export {};

package/lib/extractor/pgtype.js

@@ -0,0 +1,30 @@
+export const typeKindMap = {
+    d: "domain",
+    e: "enum",
+    r: "range",
+    // Not supported (yet):
+    // m: 'multiRange',
+    // b: 'base',
+    // p: 'pseudo',
+    // c: 'composite', -- is also a class, handled below.
+};
+export const classKindMap = {
+    r: "table",
+    p: "table", // Treat partitioned tables as tables
+    v: "view",
+    m: "materializedView",
+    c: "composite",
+    // f: "foreignTable",
+    // Not supported (yet):
+    // i: 'index',
+    // S: 'sequence',
+    // t: 'toastTable',
+    // I: 'partitionedIndex',
+};
+export const routineKindMap = {
+    // p: "procedure",
+    f: "function",
+    // Not supported (yet):
+    // a: 'aggregate',
+    // w: 'windowFunction',
+};

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { type TruePGOpts, type createGenerator } from "./types.ts";
+import { type TruePGConfig, type createGenerator } from "./types.ts";
 export { config } from "./types.ts";
 export declare const adapters: Record<string, createGenerator>;
-export declare function generate(opts: TruePGOpts, generators?: createGenerator[]): Promise<void>;
+export declare function generate(opts: TruePGConfig, generators?: createGenerator[]): Promise<void>;

package/lib/index.js

@@ -1,17 +1,16 @@
-import { Extractor } from "pg-extract";
+import { Extractor, FunctionReturnTypeKind } from "./extractor/index.js";
 import { rm, mkdir, writeFile } from "fs/promises";
 import { Nodes, allowed_kind_names } from "./types.js";
 import { existsSync } from "fs";
 import { join } from "./util.js";
 export { config } from "./types.js";
-// import { Pool } from "pg";
 import { Kysely } from "./kysely/index.js";
 import { Zod } from "./zod/index.js";
 export const adapters = {
     kysely: Kysely,
     zod: Zod,
 };
-const filter_function = (func, warnings) => {
+const filter_function = (func) => {
     const typesToFilter = [
         "pg_catalog.trigger",
         "pg_catalog.event_trigger",
@@ -21,24 +20,25 @@ const filter_function = (func, warnings) => {
         "pg_catalog.index_am_handler",
         "pg_catalog.tsm_handler",
     ];
-    const warn = (type) => warnings.push(`Skipping function ${func.name}: cannot represent ${type} (safe to ignore)`);
-    if (func.returnType.kind === "table") {
+    if (func.returnType.kind === FunctionReturnTypeKind.InlineTable) {
         for (const col of func.returnType.columns) {
             if (typesToFilter.includes(col.type.canonical_name)) {
-                warn(col.type.canonical_name);
                 return false;
             }
         }
     }
+    else if (func.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
+        if (typesToFilter.includes(func.returnType.schema + "." + func.returnType.name)) {
+            return false;
+        }
+    }
     else {
         if (typesToFilter.includes(func.returnType.type.canonical_name)) {
-            warn(func.returnType.type.canonical_name);
             return false;
         }
     }
     for (const param of func.parameters) {
         if (typesToFilter.includes(param.type.canonical_name)) {
-            warn(param.type.canonical_name);
             return false;
         }
     }
@@ -75,12 +75,18 @@ const multifile = async (generators, schemas, opts) => {
             },
         ])),
     };
-    const start = performance.now();
     for (const schema of Object.values(schemas)) {
         console.log("Selected schema '%s':\n", schema.name);
         const schemaDir = `${out}/${schema.name}`;
         // skip functions that cannot be represented in JavaScript
-        schema.functions = schema.functions.filter(f => filter_function(f, warnings));
+        schema.functions = schema.functions.filter(filter_function);
+        {
+            const skipped = schema.functions.filter(f => !filter_function(f));
+            const skipped_functions = skipped.map(f => `  - ${f.name}`).join("\n");
+            if (skipped.length) {
+                warnings.push(`Skipping ${skipped.length} functions because they cannot be represented in JavaScript (safe to ignore):\n${skipped_functions}`);
+            }
+        }
         let createIndex = false;
         for (const kind of allowed_kind_names) {
             if (schema[kind].length < 1)
@@ -101,10 +107,19 @@ const multifile = async (generators, schemas, opts) => {
                 const imports = new Nodes.ImportList([]);
                 if (item.kind === "table")
                     file += join(gens.map(gen => gen.table(imports, item)));
-                if (item.kind === "composite")
-                    file += join(gens.map(gen => gen.composite(imports, item)));
+                if (item.kind === "view")
+                    file += join(gens.map(gen => gen.view(imports, item)));
+                // prettier-ignore
+                if (item.kind === "materializedView")
+                    file += join(gens.map(gen => gen.materializedView(imports, item)));
                 if (item.kind === "enum")
                     file += join(gens.map(gen => gen.enum(imports, item)));
+                if (item.kind === "composite")
+                    file += join(gens.map(gen => gen.composite(imports, item)));
+                if (item.kind === "domain")
+                    file += join(gens.map(gen => gen.domain(imports, item)));
+                if (item.kind === "range")
+                    file += join(gens.map(gen => gen.range(imports, item)));
                 if (item.kind === "function")
                     file += join(gens.map(gen => gen.function(imports, item)));
                 const parts = [];
@@ -131,8 +146,6 @@ const multifile = async (generators, schemas, opts) => {
     const fullIndexFilename = `${out}/index.ts`;
     await write(fullIndexFilename, fullIndex);
     console.log("Created full index: %s", fullIndexFilename);
-    const end = performance.now();
-    console.log("Completed in \x1b[32m%sms\x1b[0m", (end - start).toFixed(2));
     if (warnings.length > 0) {
         console.log("\nWarnings generated:");
         console.log(warnings.map(warning => "* " + warning).join("\n"));
@@ -140,23 +153,16 @@ const multifile = async (generators, schemas, opts) => {
 };
 export async function generate(opts, generators) {
     const out = opts.out || "./models";
-    // let pg;
-    // if (opts.pg) pg = opts.pg;
-    // else if (opts.uri) pg = new Pool({ connectionString: opts.uri });
-    // else if (opts.config) pg = new Pool(opts.config);
-    // else {
-    // 	console.error(
-    // 		"One of these options are required in your config file: pg, uri, config. See documentation for more information.",
-    // 	);
-    // 	process.exit(1);
-    // }
-    const config = opts.uri ?? opts.config;
-    if (!config) {
-        console.error("One of these options are required in your config file: uri, config. See documentation for more information.");
+    if (!("uri" in opts) && !("config" in opts) && !("pg" in opts)) {
+        console.error("One of these options are required in your config file: uri, config, pg. See documentation for more information.");
         process.exit(1);
     }
-    const extractor = new Extractor(config);
+    const extractor = new Extractor(opts);
+    const start = performance.now();
     const schemas = await extractor.extractSchemas();
+    const end = performance.now();
+    console.log("Extracted schemas in \x1b[32m%sms\x1b[0m", (end - start).toFixed(2));
+    console.info("Adapters enabled: %s\n", opts.adapters.join(", "));
     generators ??= opts.adapters.map(adapter => {
         const selected = adapters[adapter];
         if (!selected)
@@ -167,4 +173,8 @@ export async function generate(opts, generators) {
     await rm(out, { recursive: true, force: true });
     await mkdir(out, { recursive: true });
     await multifile(generators, schemas, { ...opts, out });
+    {
+        const end = performance.now();
+        console.log("Completed in \x1b[32m%sms\x1b[0m", (end - start).toFixed(2));
+    }
 }

package/lib/kysely/builtins.js

@@ -4,12 +4,11 @@ export const builtins = {
     "pg_catalog.int4": "number",
     // JS numbers are always floating point, so there is only 53 bits of precision
     // for the integer part. Thus, storing a 64-bit integer in a JS number will
-    // result in potential data loss. We therefore use strings for 64-bit integers
-    // the same way that the pg driver does.
-    "pg_catalog.int8": "string",
+    // result in potential data loss.
+    "pg_catalog.int8": "bigint",
+    "pg_catalog.numeric": "bigint",
     "pg_catalog.float4": "number",
     "pg_catalog.float8": "number",
-    "pg_catalog.numeric": "string",
     "pg_catalog.bool": "boolean",
     "pg_catalog.json": "unknown",
     "pg_catalog.jsonb": "unknown",
@@ -32,4 +31,7 @@ export const builtins = {
     "pg_catalog.daterange": "string",
     "pg_catalog.record": "Record<string, unknown>",
     "pg_catalog.void": "void",
+    "pg_catalog.bytea": "string",
+    "pg_catalog.vector": "number[]",
+    "pg_catalog.tsvector": "string[]",
 };

package/lib/kysely/index.js

@@ -1,9 +1,7 @@
+import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
 import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
 import { builtins } from "./builtins.js";
-const isIdentifierInvalid = (str) => {
-    const invalid = str.match(/[^a-zA-Z0-9_]/);
-    return invalid !== null;
-};
+import { join, quote, quoteI } from "../util.js";
 const toPascalCase = (str) => str
     .replace(/^[^a-zA-Z]+/, "") // remove leading non-alphabetic characters
     .replace(/[^a-zA-Z0-9_]+/g, "") // remove non-alphanumeric/underscore characters
@@ -54,14 +52,14 @@ export const Kysely = createGenerator(opts => {
             ky(imports, "Generated");
         }
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
-        out += col.name;
+        out += quoteI(col.name);
         // TODO: update imports for non-primitive types
         out += `: ${qualified}`;
         add(imports, col.type);
         return `\t${out};\n`;
     };
     const composite_attribute = (generator, imports, attr) => {
-        let out = attr.name;
+        let out = quoteI(attr.name);
         if (attr.isNullable)
             out += "?";
         out += `: ${generator.formatType(attr.type)}`;
@@ -80,12 +78,15 @@ export const Kysely = createGenerator(opts => {
             return toPascalCase(type.name);
         },
         formatType(type) {
-            if (type.schema === "pg_catalog") {
+            if (type.kind === FunctionReturnTypeKind.ExistingTable) {
+                return toPascalCase(type.name);
+            }
+            else if (type.schema === "pg_catalog") {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
                     return format;
-                opts?.warnings?.push(`Unknown builtin type: ${name}! Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
+                opts?.warnings?.push(`(kysely) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
                 return "unknown";
             }
             return toPascalCase(type.name);
@@ -100,6 +101,26 @@ export const Kysely = createGenerator(opts => {
             out += "}";
             return out;
         },
+        view(imports, view) {
+            let out = "";
+            if (view.comment)
+                out += `/** ${view.comment} */\n`;
+            out += `export interface ${this.formatSchemaType(view)} {\n`;
+            for (const col of view.columns)
+                out += column(this, imports, col);
+            out += "}";
+            return out;
+        },
+        materializedView(imports, materializedView) {
+            let out = "";
+            if (materializedView.comment)
+                out += `/** ${materializedView.comment} */\n`;
+            out += `export interface ${this.formatSchemaType(materializedView)} {\n`;
+            for (const col of materializedView.columns)
+                out += column(this, imports, col);
+            out += "}";
+            return out;
+        },
         enum(imports, en) {
             let out = "";
             if (en.comment)
@@ -117,6 +138,17 @@ export const Kysely = createGenerator(opts => {
             out += "\n}";
             return out;
         },
+        domain(imports, type) {
+            let out = "";
+            out += `export type ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
+            return out;
+        },
+        range(imports, type) {
+            let out = "";
+            // force this to be string because range has to be passed as a string to Kysely
+            out += `export type ${this.formatSchemaType(type)} = string;`;
+            return out;
+        },
         function(imports, type) {
             let out = "";
             out += "/**\n";
@@ -161,17 +193,25 @@ export const Kysely = createGenerator(opts => {
                 }
                 out += "\t): ";
             }
-            if (type.returnType.kind === "table") {
-                out += "{\n";
-                for (const col of type.returnType.columns) {
-                    out += `\t\t${col.name}: `;
-                    out += this.formatType(col.type);
-                    add(imports, col.type);
-                    if (col.type.dimensions > 0)
-                        out += "[]".repeat(col.type.dimensions);
-                    out += `;\n`;
+            if (type.returnType.kind === FunctionReturnTypeKind.InlineTable) {
+                if (type.returnType.columns.length === 0)
+                    out += "void/* RETURNS TABLE with no columns */";
+                else {
+                    out += "{\n";
+                    for (const col of type.returnType.columns) {
+                        out += `\t\t"${col.name}": `;
+                        out += this.formatType(col.type);
+                        add(imports, col.type);
+                        if (col.type.dimensions > 0)
+                            out += "[]".repeat(col.type.dimensions);
+                        out += `;\n`;
+                    }
+                    out += "\t}";
                 }
-                out += "\t}";
+            }
+            else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
+                out += this.formatType(type.returnType);
+                add(imports, type.returnType);
             }
             else {
                 out += this.formatType(type.returnType.type);
@@ -200,10 +240,11 @@ export const Kysely = createGenerator(opts => {
                 .join("\n");
         },
         schemaIndex(schema) {
-            let out = allowed_kind_names.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
+            const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
+            let out = actual_kinds.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
             out += "\n\n";
             out += `export interface ${this.formatSchema(schema.name)} {\n`;
-            for (const kind of allowed_kind_names) {
+            for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
                     continue;
@@ -216,9 +257,7 @@ export const Kysely = createGenerator(opts => {
                     .filter(x => x !== undefined);
                 out += formatted
                     .map(t => {
-                    let name = t.name;
-                    if (isIdentifierInvalid(name))
-                        name = `"${name}"`;
+                    let name = quoteI(t.name);
                     return `\t\t${name}: ${t.kind}s.${t.formatted};`;
                 })
                     .join("\n");
@@ -228,45 +267,50 @@ export const Kysely = createGenerator(opts => {
             return out;
         },
         fullIndex(schemas) {
-            let out = "";
-            out += schemas
+            const parts = [];
+            parts.push(schemas
                 .map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
-                .join("\n");
-            out += "\n\n";
-            out += `export interface Database {\n`;
-            out += schemas
-                .map(schema => {
-                // Kysely only wants tables
-                const tables = schema.tables;
-                let out = "";
-                const seen = new Set();
-                const formatted = tables
-                    .map(each => {
-                    const formatted = this.formatSchemaType(each);
-                    // skip clashing names
-                    if (seen.has(formatted))
-                        return;
-                    seen.add(formatted);
-                    return { ...each, formatted };
-                })
-                    .filter(x => x !== undefined);
-                if (out.length)
-                    out += "\n\n";
-                out += formatted
-                    .map(t => {
-                    const prefix = defaultSchema === schema.name ? "" : schema.name + ".";
-                    let qualified = prefix + t.name;
-                    if (isIdentifierInvalid(qualified))
-                        qualified = `"${qualified}"`;
-                    return `\t${qualified}: ${this.formatSchema(schema.name)}["${t.kind}s"]["${t.name}"];`;
+                .join("\n"));
+            {
+                let iface = `export interface Database {\n`;
+                iface += schemas
+                    .map(schema => {
+                    // only tables, views, and materialized views are queryable
+                    const tables = [...schema.tables, ...schema.views, ...schema.materializedViews];
+                    let out = "";
+                    const seen = new Set();
+                    const formatted = tables
+                        .map(each => {
+                        const formatted = this.formatSchemaType(each);
+                        // skip clashing names
+                        if (seen.has(formatted))
+                            return;
+                        seen.add(formatted);
+                        return { ...each, formatted };
+                    })
+                        .filter(x => x !== undefined);
+                    if (out.length)
+                        out += "\n\n";
+                    out += formatted
+                        .map(t => {
+                        const isDefault = defaultSchema === schema.name;
+                        let qualified = "";
+                        if (!isDefault)
+                            qualified = schema.name + "." + t.name;
+                        else
+                            qualified = t.name;
+                        qualified = quoteI(qualified);
+                        return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
+                    })
+                        .join("\n");
+                    return out;
                 })
                     .join("\n");
-                return out;
-            })
-                .join("");
-            out += "\n}\n\n";
-            out += schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n");
-            return out;
+                iface += "\n}";
+                parts.push(iface);
+            }
+            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            return join(parts);
         },
     };
     return generator;

package/lib/types.d.ts

@@ -1,5 +1,5 @@
-import type { CanonicalType, CompositeTypeDetails, EnumDetails, FunctionDetails, TableDetails, SchemaType, Schema, Extractor } from "pg-extract";
-export declare const allowed_kind_names: readonly ["tables", "enums", "composites", "functions"];
+import { Canonical, type Extractor, type TableDetails, type ViewDetails, type MaterializedViewDetails, type EnumDetails, type CompositeTypeDetails, type DomainDetails, type RangeDetails, type FunctionDetails, type SchemaType, type Schema, type FunctionReturnType } from "./extractor/index.ts";
+export declare const allowed_kind_names: readonly ["tables", "views", "materializedViews", "enums", "composites", "functions", "domains", "ranges"];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
     name: string;
@@ -39,13 +39,13 @@ export declare namespace Nodes {
     }
     class InternalImport {
         name: string;
-        canonical_type: CanonicalType;
+        canonical_type: Canonical | FunctionReturnType.ExistingTable;
         typeOnly: boolean;
         star: boolean;
         external: false;
         constructor(args: {
             name: string;
-            canonical_type: CanonicalType;
+            canonical_type: Canonical | FunctionReturnType.ExistingTable;
             typeOnly: boolean;
             star: boolean;
         });
@@ -64,15 +64,23 @@ export declare namespace Nodes {
         star: boolean;
     }
 }
-export type ConnectionConfig = Exclude<ConstructorParameters<typeof Extractor>[0], string | undefined>;
-export interface TruePGOpts {
-    uri?: string;
-    config?: ConnectionConfig;
+export type ExtractorConfig = Exclude<ConstructorParameters<typeof Extractor>[0], string | undefined>;
+export interface BaseConfig {
     out: string;
     adapters: string[];
     defaultSchema?: string;
 }
-export declare function config(opts: TruePGOpts): TruePGOpts;
+export interface PgConfig extends BaseConfig {
+    pg: ExtractorConfig["pg"];
+}
+export interface UriConfig extends BaseConfig {
+    uri: ExtractorConfig["uri"];
+}
+export interface ConfigConfig extends BaseConfig {
+    config: ExtractorConfig["config"];
+}
+export type TruePGConfig = PgConfig | UriConfig | ConfigConfig;
+export declare function config(opts: TruePGConfig): TruePGConfig;
 export interface CreateGeneratorOpts {
     defaultSchema?: string;
     warnings: string[];
@@ -99,12 +107,22 @@ export interface SchemaGenerator {
      * This is useful if you want to use a different name for a type in the generated code.
      * Example: "users" -> "UsersTable"
      */
-    formatType(type: CanonicalType): string;
+    formatType(type: Canonical | FunctionReturnType.ExistingTable): string;
     table(
     /** @out Append used types to this array */
     imports: Nodes.ImportList, 
     /** Information about the table */
     table: TableDetails): string;
+    view(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the view */
+    view: ViewDetails): string;
+    materializedView(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the materialized view */
+    materializedView: MaterializedViewDetails): string;
     enum(
     /** @out Append used types to this array */
     imports: Nodes.ImportList, 
@@ -115,6 +133,16 @@ export interface SchemaGenerator {
     imports: Nodes.ImportList, 
     /** Information about the composite type */
     type: CompositeTypeDetails): string;
+    domain(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the domain */
+    type: DomainDetails): string;
+    range(
+    /** @out Append used types to this array */
+    imports: Nodes.ImportList, 
+    /** Information about the range */
+    type: RangeDetails): string;
     function(
     /** @out Append used types to this array */
     imports: Nodes.ImportList, 

package/lib/types.js

@@ -1,8 +1,17 @@
-// import type { ClientConfig, Pool, PoolConfig } from "pg";
-import { dirname, relative } from "node:path";
+import { Canonical, } from "./extractor/index.js";
+import { dirname, relative } from "node:path/posix";
 import { join } from "./util.js";
 // To be updated when we add support for other kinds
-export const allowed_kind_names = ["tables", "enums", "composites", "functions"];
+export const allowed_kind_names = [
+    "tables",
+    "views",
+    "materializedViews",
+    "enums",
+    "composites",
+    "functions",
+    "domains",
+    "ranges",
+];
 export var Nodes;
 (function (Nodes) {
     class ExternalImport {
@@ -120,6 +129,8 @@ export var Nodes;
                             int2.kind === int.kind);
                     }) === index);
                 })
+                    .filter(imp => imp.canonical_type.kind === Canonical.Kind.Base ||
+                    allowed_kind_names.includes(`${imp.canonical_type.kind}s`))
                     .map(imp => {
                     const t = imp.canonical_type;
                     const schema = files.children[t.schema];

package/lib/util.d.ts

@@ -1 +1,12 @@
 export declare const join: (parts: Iterable<string>, joiner?: string) => string;
+export type UnionKeys<T> = T extends unknown ? keyof T : never;
+type AddOptionalKeys<K extends PropertyKey> = {
+    [P in K]?: never;
+};
+export type Deunionise<B extends object | undefined, T = B> = Simplify<T extends object ? T & AddOptionalKeys<Exclude<UnionKeys<B>, keyof T>> : T>;
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+export declare const quote: (str: string, using?: string) => string;
+export declare const quoteI: (str: string, using?: string) => string;
+export {};

package/lib/util.js

@@ -1 +1,7 @@
 export const join = (parts, joiner = "\n\n") => Array.from(parts).filter(Boolean).join(joiner);
+const isIdentifierInvalid = (str) => {
+    const invalid = str.match(/[^a-zA-Z0-9_]/);
+    return invalid !== null;
+};
+export const quote = (str, using = '"') => `${using}${str.replaceAll(using, "\\" + using)}${using}`;
+export const quoteI = (str, using = '"') => (isIdentifierInvalid(str) ? quote(str, using) : str);