csv-to-pg 0.6.2 → 2.0.2

package/parser.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+// @ts-nocheck
+const fs_1 = require("fs");
+const index_1 = require("./index");
+const pgsql_deparser_1 = require("pgsql-deparser");
+const utils_1 = require("./utils");
+class Parser {
+    constructor(config) {
+        this.config = config;
+    }
+    async parse(data) {
+        const config = this.config;
+        const { schema, table, singleStmts, conflict, headers, delimeter } = config;
+        const opts = {};
+        if (headers)
+            opts.headers = headers;
+        if (delimeter)
+            opts.separator = delimeter;
+        let records;
+        if (typeof data === 'undefined') {
+            if (config.json || config.input.endsWith('.json')) {
+                records = JSON.parse((0, fs_1.readFileSync)(config.input, 'utf-8'));
+            }
+            else {
+                records = await (0, index_1.parse)(config.input, opts);
+            }
+        }
+        else {
+            if (!Array.isArray(data)) {
+                throw new Error('data is not an array');
+            }
+            records = data;
+        }
+        if (config.debug) {
+            console.log(records);
+            return;
+        }
+        const types = (0, index_1.parseTypes)(config);
+        if (singleStmts) {
+            const stmts = records.map((record) => (0, utils_1.InsertOne)({
+                schema,
+                table,
+                types,
+                record,
+                conflict
+            }));
+            return (0, pgsql_deparser_1.deparse)(stmts);
+        }
+        else {
+            const stmt = (0, utils_1.InsertMany)({
+                schema,
+                table,
+                types,
+                records,
+                conflict
+            });
+            return (0, pgsql_deparser_1.deparse)([stmt]);
+        }
+    }
+}
+exports.Parser = Parser;

package/utils.d.ts

@@ -0,0 +1,135 @@
+export declare const normalizePath: (path: any, cwd: any) => any;
+export declare const makeLocation: (longitude: any, latitude: any) => {
+    Null: {};
+} | {
+    FuncCall: {};
+};
+export declare const makeBoundingBox: (bbox: any) => {
+    FuncCall: {};
+};
+export declare const InsertOne: ({ schema, table, types, record, conflict }: {
+    schema?: string;
+    table: any;
+    types: any;
+    record: any;
+    conflict: any;
+}) => {
+    RawStmt: {
+        stmt: {
+            InsertStmt: {
+                relation: {
+                    RangeVar: {
+                        schemaname: string;
+                        relname: any;
+                        inh: boolean;
+                        relpersistence: string;
+                    };
+                };
+                cols: {
+                    ResTarget: {};
+                }[];
+                selectStmt: {
+                    SelectStmt: {
+                        valuesLists: any[][];
+                        op: number;
+                    };
+                };
+                onConflictClause: {
+                    OnConflictClause: {
+                        action: number;
+                        infer: {
+                            InferClause: {
+                                indexElems: any;
+                            };
+                        };
+                        targetList: any;
+                    };
+                } | {
+                    OnConflictClause: {
+                        action: number;
+                        infer: {
+                            InferClause: {
+                                indexElems: any;
+                            };
+                        };
+                        targetList?: undefined;
+                    };
+                };
+                override: number;
+            };
+        };
+        stmt_len: number;
+    };
+};
+export declare const InsertMany: ({ schema, table, types, records, conflict }: {
+    schema?: string;
+    table: any;
+    types: any;
+    records: any;
+    conflict: any;
+}) => {
+    RawStmt: {
+        stmt: {
+            InsertStmt: {
+                relation: {
+                    RangeVar: {
+                        schemaname: string;
+                        relname: any;
+                        inh: boolean;
+                        relpersistence: string;
+                    };
+                };
+                cols: {
+                    ResTarget: {};
+                }[];
+                selectStmt: {
+                    SelectStmt: {
+                        valuesLists: any;
+                        op: number;
+                    };
+                };
+                onConflictClause: {
+                    OnConflictClause: {
+                        action: number;
+                        infer: {
+                            InferClause: {
+                                indexElems: any;
+                            };
+                        };
+                        targetList: any;
+                    };
+                } | {
+                    OnConflictClause: {
+                        action: number;
+                        infer: {
+                            InferClause: {
+                                indexElems: any;
+                            };
+                        };
+                        targetList?: undefined;
+                    };
+                };
+                override: number;
+            };
+        };
+        stmt_len: number;
+    };
+};
+export declare const wrapValue: (val: any, { wrap, wrapAst, cast }?: {
+    wrap: any;
+    wrapAst: any;
+    cast: any;
+}) => any;
+export declare const getRelatedField: ({ schema, table, refType, refKey, refField, wrap, wrapAst, cast, record, parse, from }: {
+    schema?: string;
+    table: any;
+    refType: any;
+    refKey: any;
+    refField: any;
+    wrap: any;
+    wrapAst: any;
+    cast: any;
+    record: any;
+    parse: any;
+    from: any;
+}) => any;

package/utils.js

@@ -0,0 +1,300 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedField = exports.wrapValue = exports.InsertMany = exports.InsertOne = exports.makeBoundingBox = exports.makeLocation = exports.normalizePath = void 0;
+// @ts-nocheck
+const ast = __importStar(require("pg-ast"));
+const path_1 = require("path");
+const normalizePath = (path, cwd) => path.startsWith('/') ? path : (0, path_1.resolve)((0, path_1.join)(cwd ? cwd : process.cwd(), path));
+exports.normalizePath = normalizePath;
+const lstr = (bbox) => {
+    const [lng1, lat1, lng2, lat2] = bbox.split(',').map((a) => a.trim());
+    return `LINESTRING(${lng1} ${lat1}, ${lng1} ${lat2}, ${lng2} ${lat2}, ${lng2} ${lat1}, ${lng1} ${lat1})`;
+};
+const funcCall = (name, args) => {
+    return ast.FuncCall({
+        funcname: [ast.String({ str: name })],
+        args
+    });
+};
+const aflt = (num) => ast.A_Const({ val: ast.Float({ str: num }) });
+const aint = (num) => ast.A_Const({ val: ast.Integer({ ival: num }) });
+const makeLocation = (longitude, latitude) => {
+    if (!longitude || !latitude) {
+        return ast.Null();
+    }
+    return funcCall('st_setsrid', [
+        funcCall('st_makepoint', [aflt(longitude), aflt(latitude)]),
+        aint(4326)
+    ]);
+};
+exports.makeLocation = makeLocation;
+// a string in the form of lon,lat,lon,lat
+// -118.587533,34.024999,-118.495177,34.13165
+const makeBoundingBox = (bbox) => {
+    return funcCall('st_setsrid', [
+        funcCall('st_makepolygon', [
+            funcCall('st_geomfromtext', [
+                ast.A_Const({ val: ast.String({ str: lstr(bbox) }) })
+            ])
+        ]),
+        aint(4326)
+    ]);
+};
+exports.makeBoundingBox = makeBoundingBox;
+const ValuesLists = ({ types, record }) => Object.entries(types).map(([field, type]) => {
+    if (typeof type === 'function') {
+        return type(record);
+    }
+    throw new Error('coercion function missing');
+});
+const makeCast = (arg, type) => ({
+    TypeCast: {
+        arg,
+        typeName: {
+            TypeName: {
+                names: [
+                    {
+                        String: {
+                            str: type
+                        }
+                    }
+                ],
+                typemod: -1
+            }
+        }
+    }
+});
+const ref = (name) => ({
+    ResTarget: {
+        name,
+        val: {
+            ColumnRef: {
+                fields: [
+                    {
+                        String: {
+                            str: 'excluded'
+                        }
+                    },
+                    {
+                        String: {
+                            str: name
+                        }
+                    }
+                ]
+            }
+        }
+    }
+});
+const indexElem = (name) => ({
+    IndexElem: {
+        name,
+        ordering: 0,
+        nulls_ordering: 0
+    }
+});
+const makeConflictClause = (conflictElems, fields) => {
+    if (!conflictElems || !conflictElems.length)
+        return undefined;
+    const setElems = fields.filter((el) => !conflictElems.includes(el));
+    if (setElems.length) {
+        return {
+            OnConflictClause: {
+                action: 2,
+                infer: {
+                    InferClause: {
+                        indexElems: conflictElems.map((a) => indexElem(a))
+                    }
+                },
+                targetList: setElems.map((a) => ref(a))
+            }
+        };
+    }
+    else {
+        return {
+            OnConflictClause: {
+                action: 1,
+                infer: {
+                    InferClause: {
+                        indexElems: conflictElems.map((a) => indexElem(a))
+                    }
+                }
+            }
+        };
+    }
+};
+const InsertOne = ({ schema = 'public', table, types, record, conflict }) => ({
+    RawStmt: {
+        stmt: {
+            InsertStmt: {
+                relation: {
+                    RangeVar: {
+                        schemaname: schema,
+                        relname: table,
+                        inh: true,
+                        relpersistence: 'p'
+                    }
+                },
+                cols: Object.keys(types).map((field) => ast.ResTarget({ name: field })),
+                selectStmt: {
+                    SelectStmt: {
+                        valuesLists: [ValuesLists({ types, record })],
+                        op: 0
+                    }
+                },
+                onConflictClause: makeConflictClause(conflict, Object.keys(types)),
+                override: 0
+            }
+        },
+        stmt_len: 1
+    }
+});
+exports.InsertOne = InsertOne;
+const InsertMany = ({ schema = 'public', table, types, records, conflict }) => ({
+    RawStmt: {
+        stmt: {
+            InsertStmt: {
+                relation: {
+                    RangeVar: {
+                        schemaname: schema,
+                        relname: table,
+                        inh: true,
+                        relpersistence: 'p'
+                    }
+                },
+                cols: Object.keys(types).map((field) => ast.ResTarget({ name: field })),
+                selectStmt: {
+                    SelectStmt: {
+                        valuesLists: records.map((record) => ValuesLists({ types, record })),
+                        op: 0
+                    }
+                },
+                onConflictClause: makeConflictClause(conflict, Object.keys(types)),
+                override: 0
+            }
+        },
+        stmt_len: 1
+    }
+});
+exports.InsertMany = InsertMany;
+const wrapValue = (val, { wrap, wrapAst, cast } = {}) => {
+    if (Array.isArray(wrap)) {
+        val = ast.FuncCall({
+            funcname: wrap.map((n) => ast.String({ str: n })),
+            args: [val]
+        });
+    }
+    if (wrapAst)
+        return wrapAst(val);
+    if (cast)
+        return makeCast(val, cast);
+    return val;
+};
+exports.wrapValue = wrapValue;
+const getRelatedField = ({ schema = 'public', table, refType, refKey, refField, wrap, wrapAst, cast, record, parse, from }) => {
+    let val;
+    const value = parse(record[from[0]]);
+    if (typeof value === 'undefined') {
+        return ast.Null({});
+    }
+    switch (refType) {
+        case 'int':
+            val = ast.A_Const({ val: ast.Integer({ ival: value }) });
+            break;
+        case 'float':
+            val = ast.A_Const({ val: ast.Float({ str: value }) });
+            break;
+        case 'boolean':
+        case 'bool':
+            val = ast.String({ str: value ? 'TRUE' : 'FALSE' });
+            break;
+        case 'text':
+        default:
+            val = ast.A_Const({ val: ast.String({ str: value }) });
+    }
+    val = (0, exports.wrapValue)(val, { wrap, wrapAst });
+    return (0, exports.wrapValue)({
+        SubLink: {
+            subLinkType: 4,
+            subselect: {
+                SelectStmt: {
+                    targetList: [
+                        {
+                            ResTarget: {
+                                val: {
+                                    ColumnRef: {
+                                        fields: [
+                                            {
+                                                String: {
+                                                    str: refKey
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            }
+                        }
+                    ],
+                    fromClause: [
+                        {
+                            RangeVar: {
+                                schemaname: schema,
+                                relname: table,
+                                inh: true,
+                                relpersistence: 'p'
+                            }
+                        }
+                    ],
+                    whereClause: {
+                        A_Expr: {
+                            kind: 0,
+                            name: [
+                                {
+                                    String: {
+                                        str: '='
+                                    }
+                                }
+                            ],
+                            lexpr: {
+                                ColumnRef: {
+                                    fields: [
+                                        {
+                                            String: {
+                                                str: refField
+                                            }
+                                        }
+                                    ]
+                                }
+                            },
+                            rexpr: val
+                        }
+                    },
+                    op: 0
+                }
+            }
+        }
+    }, { cast });
+};
+exports.getRelatedField = getRelatedField;

package/main/cli.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _prompt = require("@pyramation/prompt");
-
-var _parse = require("./parse");
-
-var _parser = require("./parser");
-
-var _utils = require("./utils");
-
-var _path = require("path");
-
-var _fs = require("fs");
-
-var argv = process.argv.slice(2);
-(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
-  var _yield$prompt, config, dir, results, outFile, parser, sql;
-
-  return _regenerator["default"].wrap(function _callee$(_context) {
-    while (1) {
-      switch (_context.prev = _context.next) {
-        case 0:
-          _context.next = 2;
-          return (0, _prompt.prompt)([{
-            _: true,
-            name: 'config',
-            type: 'config',
-            required: true
-          }], argv);
-
-        case 2:
-          _yield$prompt = _context.sent;
-          config = _yield$prompt.config;
-          config = (0, _utils.normalizePath)(config);
-          dir = (0, _path.dirname)(config);
-          config = (0, _parse.readConfig)(config);
-
-          if (config.input) {
-            if (!argv.includes('--input')) {
-              argv.push('--input');
-              config.input = (0, _utils.normalizePath)(config.input, dir);
-              argv.push(config.input);
-            }
-          }
-
-          if (config.output) {
-            if (!argv.includes('--output')) {
-              argv.push('--output');
-              config.output = (0, _utils.normalizePath)(config.output, dir);
-              argv.push(config.output);
-            }
-          }
-
-          _context.next = 11;
-          return (0, _prompt.prompt)([{
-            name: 'input',
-            type: 'path',
-            required: true
-          }, {
-            name: 'output',
-            type: 'path',
-            required: true
-          }], argv);
-
-        case 11:
-          results = _context.sent;
-          config.input = results.input;
-          outFile = results.output;
-          if (!outFile.endsWith('.sql')) outFile = outFile + '.sql';
-
-          if (argv.includes('--debug')) {
-            config.debug = true;
-          }
-
-          parser = new _parser.Parser(config);
-          _context.next = 19;
-          return parser.parse();
-
-        case 19:
-          sql = _context.sent;
-          (0, _fs.writeFileSync)(config.output, sql);
-
-        case 21:
-        case "end":
-          return _context.stop();
-      }
-    }
-  }, _callee);
-}))();

package/main/index.js

@@ -1,29 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _parse = require("./parse");
-
-Object.keys(_parse).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _parse[key];
-    }
-  });
-});
-
-var _parser = require("./parser");
-
-Object.keys(_parser).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _parser[key];
-    }
-  });
-});