prostgles-types 4.0.281 → 4.0.283

package/lib/index.ts

@@ -117,6 +117,8 @@ export type DBTableSchema = {
    * fields that are nullable or with a default value are be optional
    */
   columns: AnyObject;
+  /** Client insert input; omitted on schemas that use the database column defaults. */
+  insertColumns?: AnyObject;
   /**
    * TODO: extract references and update InsertDataWithNested type to allow nested inserts based on the references
    * Table names and their columns that reference the current table through foreign keys.
@@ -582,7 +584,7 @@ type InclusiveSelect = true | 1 | FunctionSelect | JoinSelect;
 type SelectWithFunctions<T extends AnyObject = AnyObject, IsTyped = false> =
   | ({ [K in keyof Partial<T>]: InclusiveSelect } & Record<
       string,
-      IsTyped extends true ? FunctionFull : InclusiveSelect
+      IsTyped extends true ? FunctionFull | DetailedJoinSelect : InclusiveSelect
     >)
   | FunctionAliasedSelect
   | { [K in keyof Partial<T>]: true | 1 | string }
@@ -757,31 +759,61 @@ export type NormalizedRow<T extends Record<string, unknown>> = Required<{
   [K in keyof T]: CollapseNumberIfStringPresent<T[K]>;
 }>;
 
+type JoinTarget<P> =
+  P extends string ? P
+  : P extends readonly [...unknown[], infer Last] ?
+    Last extends string ? Last
+    : Last extends { table: infer T } ? T
+    : never
+  : never;
+
+type ExplicitJoinResult<J, S extends DBSchema | void, P> =
+  [JoinTarget<P>] extends [never] ? any[]
+  : S extends DBSchema ?
+    JoinTarget<P> extends infer T extends keyof S ?
+      J extends { select: infer Sel extends Select } ?
+        SelectDataType<S, { select: Sel }, S[T]["columns"]>[]
+      : any[]
+    : any[]
+  : any[];
+
 type JoinedSelect = Record<string, Select>;
 export type SelectFunction = Record<string, any[]>;
 type ParseSelect<
   Select extends SelectParams<TD>["select"],
   TD extends AnyObject,
+  S extends DBSchema | void,
 > = (Select extends { "*": 1 } ? NormalizedRow<TD> : {}) & {
-  [Key in keyof Omit<Select, "*"> & string]: Select[Key] extends 1 ? NormalizedRow<TD>[Key]
+  [Key in keyof Omit<Select, "*"> & string]: Select[Key] extends 1 | true ? NormalizedRow<TD>[Key]
+  : Select[Key] extends (
+    {
+      $leftJoin: infer P extends RawJoinPath;
+      select: unknown;
+    }
+  ) ?
+    ExplicitJoinResult<Select[Key], S, P>
+  : Select[Key] extends (
+    {
+      $innerJoin: infer P extends RawJoinPath;
+      select: unknown;
+    }
+  ) ?
+    ExplicitJoinResult<Select[Key], S, P>
   : Select[Key] extends SelectFunction ? any
   : Select[Key] extends JoinedSelect ? any[]
   : any;
 };
 
-type SelectDataType<
-  S extends DBSchema | void,
-  O extends SelectParams<TD, S>,
-  TD extends AnyObject,
-> =
+type SelectDataType<S extends DBSchema | void, O, TD extends AnyObject> =
   O extends { returnType: "value" } ? any
   : O extends { returnType: "values"; select: Record<string, 1> } ?
     ValueOf<Pick<NormalizedRow<TD>, keyof O["select"]>>
   : O extends { returnType: "values" } ? any
   : O extends { select: "*" } ? NormalizedRow<TD>
   : O extends { select: "" } ? Record<string, never>
-  : O extends { select: Record<string, 0> } ? Omit<NormalizedRow<TD>, keyof O["select"]>
-  : O extends { select: Record<string, any> } ? ParseSelect<O["select"], NormalizedRow<TD>>
+  : O extends { select: readonly (keyof TD)[] } ? Pick<NormalizedRow<TD>, O["select"][number]>
+  : O extends { select: Record<string, 0 | false> } ? Omit<NormalizedRow<TD>, keyof O["select"]>
+  : O extends { select: Record<string, any> } ? ParseSelect<O["select"], NormalizedRow<TD>, S>
   : NormalizedRow<TD>;
 
 export type SelectReturnType<
@@ -901,7 +933,7 @@ export type InsertDataWithNested<
   TD extends AnyObject,
   S extends DBSchema | void,
   TName extends PropertyKey = never,
-> = InsertColumnsWithReferences<TD, S, TName> &
+> = InsertColumnsWithReferences<GetInsertColumns<TD, S, TName>, S, TName> &
   (S extends DBSchema ?
     string extends keyof S ?
       {} // collapse to void-like behavior for untyped/dynamic schema
@@ -910,6 +942,11 @@ export type InsertDataWithNested<
       }
   : {});
 
+type GetInsertColumns<TD extends AnyObject, S, TName extends PropertyKey> =
+  [TName] extends [never] ? TD
+  : S extends Record<TName, { insertColumns: infer Columns extends AnyObject }> ? Columns
+  : TD;
+
 /**
  * Methods for interacting with a table/view
  * - On client-side some methods are restricted (and undefined) based on publish rules on the server

package/lib/insertTypes.ts

@@ -20,13 +20,19 @@ export type InsertColumnsWithReferences<
       }
   : never;
 
-type ColumnReferences<S extends DBSchema | void, TName extends PropertyKey> = {
-  [F in keyof S]: S[F] extends (
-    {
-      columns: infer Data extends AnyObject;
+// Compute the reference-bearing tables once per schema, independently of the insert target.
+type SchemaReferences<S> = {
+  [F in keyof S]: S[F] extends {
+    columns: infer Data extends AnyObject;
+    referencedBy: infer References;
+  } ? { name: F; data: Data; referencedBy: References } : never;
+}[keyof S];
+
+type ColumnReferences<S extends DBSchema | void, TName extends PropertyKey> =
+  SchemaReferences<S> extends infer Table ?
+    Table extends {
+      name: infer F extends PropertyKey;
+      data: infer Data extends AnyObject;
       referencedBy: Record<TName, infer Columns>;
-    }
-  ) ?
-    { columns: Columns; data: InsertDataWithNested<Data, S, F> }
+    } ? { columns: Columns; data: InsertDataWithNested<Data, S, F> } : never
   : never;
-}[keyof S];

package/lib/joinHelpers.ts

@@ -1,6 +1,9 @@
-import type { AnyObject, JoinMaker } from "./index";
+import type { AnyObject, DetailedJoinSelect, JoinMaker } from "./index";
 import { omitKeys } from "./util";
 
+/** Preserve literal table names and selections for joined return type inference. */
+export const defineJoin = <const J extends DetailedJoinSelect>(join: J): J => join;
+
 const getJoinFunc = (joinType: "$leftJoin" | "$innerJoin" = "$leftJoin") => {
   const joinMaker: JoinMaker = (
     tableName: Parameters<JoinMaker<AnyObject>>[0],

package/package.json

@@ -1,16 +1,22 @@
 {
   "name": "prostgles-types",
-  "version": "4.0.281",
+  "version": "4.0.283",
   "description": "",
   "main": "dist/index_umd.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib",
+    "!**/*.spec.*"
+  ],
   "directories": {},
   "scripts": {
     "start": "tsc --watch",
     "test": "npm run build && npm run test:type-instantiations && node --test dist/*.spec.js dist/**/*.spec.js",
     "test:type-instantiations": "node scripts/check-type-instantiations.mjs",
-    "build": "npm i && rm -rf ./dist/* && tsc && webpack --config webpack.prod.js",
+    "build": "rm -rf ./dist/* && tsc && webpack --config webpack.prod.js",
     "prebuild": "tsc --noEmit -p tsconfig.browser.json",
+    "prepack": "npm run build",
     "perf": "tsc --extendedDiagnostics 2>&1 | grep -E \"Instantiations|Check time\"",
     "pushpublish": "npm version patch --git-tag-version false && git push && npm publish"
   },

package/.vscode/settings.json

@@ -1,12 +0,0 @@
-{
-  "typescript.tsdk": "node_modules/typescript/lib",
-  "editor.formatOnSave": true,
-  "prettier.experimentalTernaries": true,
-  "[javascript]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "[typescript]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-  },
-  "prettier.printWidth": 100
-}

package/scripts/check-type-instantiations.mjs

@@ -1,40 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-// Baseline: 108,997. The small margin avoids hiding meaningful inference regressions.
-const MAX_INSTANTIATIONS = 105_000;
-const tscPath = fileURLToPath(new URL("../node_modules/typescript/bin/tsc", import.meta.url));
-const result = spawnSync(
-  process.execPath,
-  [tscPath, "--noEmit", "--extendedDiagnostics", "--pretty", "false"],
-  { encoding: "utf8" },
-);
-
-if (result.error) {
-  throw result.error;
-}
-
-if (result.status !== 0) {
-  process.stdout.write(result.stdout);
-  process.stderr.write(result.stderr);
-  process.exit(result.status ?? 1);
-}
-
-const output = result.stdout + result.stderr;
-const label = "Instantiations:";
-const line = output.split("\n").find((outputLine) => outputLine.startsWith(label));
-const instantiations = Number(line?.slice(label.length).trim());
-
-if (!Number.isFinite(instantiations)) {
-  throw new Error(`Could not read type instantiations from tsc output:\n${output}`);
-}
-
-if (instantiations > MAX_INSTANTIATIONS) {
-  throw new Error(
-    `Type instantiations increased to ${instantiations.toLocaleString()} (maximum: ${MAX_INSTANTIATIONS.toLocaleString()}).`,
-  );
-}
-
-console.log(
-  `Type instantiations: ${instantiations.toLocaleString()} / ${MAX_INSTANTIATIONS.toLocaleString()}`,
-);