@casekit/orm 0.0.1-alpha.8 → 0.0.1-release-candidate

package/build/util/getLateralJoinValues.test.js

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "vitest";
+import { getLateralJoinValues } from "./getLateralJoinValues.js";
+describe("getLateralJoinValues", () => {
+    test("should handle flat objects with direct mapping", () => {
+        const results = [
+            { id: 1, name: "John" },
+            { id: 2, name: "Jane" },
+            { id: 2, name: "Jane" }, // Duplicate to test uniqueness
+        ];
+        const result = getLateralJoinValues(results, [], // empty path for top-level properties
+        ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle nested objects with path", () => {
+        const results = [
+            { user: { id: 1, name: "John" } },
+            { user: { id: 2, name: "Jane" } },
+        ];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle missing nested objects", () => {
+        const results = [
+            { user: { id: 1, name: "John" } },
+            { user: null },
+            { user: { id: 2, name: "Jane" } },
+        ];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test(" handle deeply nested paths", () => {
+        const results = [
+            { data: { user: { profile: { id: 1, name: "John" } } } },
+            { data: { user: { profile: { id: 2, name: "Jane" } } } },
+        ];
+        const result = getLateralJoinValues(results, ["data", "user", "profile"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+            {
+                field: "userName",
+                values: ["John", "Jane"],
+            },
+        ]);
+    });
+    test("should handle empty results array", () => {
+        const results = [];
+        const result = getLateralJoinValues(results, ["user"], ["id", "name"], ["userId", "userName"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [],
+            },
+            {
+                field: "userName",
+                values: [],
+            },
+        ]);
+    });
+    test("should handle single field mapping", () => {
+        const results = [{ id: 1 }, { id: 2 }];
+        const result = getLateralJoinValues(results, [], ["id"], ["userId"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                values: [1, 2],
+            },
+        ]);
+    });
+});

package/build/util/hasClauses.d.ts

@@ -0,0 +1 @@
+export declare const hasClauses: <T>(clause: T) => clause is NonNullable<T>;

package/build/util/hasClauses.js

@@ -0,0 +1,9 @@
+export const hasClauses = (clause) => {
+    if (clause === null || clause === undefined || typeof clause !== "object")
+        return false;
+    const keys = [
+        ...Object.keys(clause),
+        ...Object.getOwnPropertySymbols(clause),
+    ];
+    return keys.length > 0;
+};

package/build/util/hasClauses.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/hasClauses.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, test } from "vitest";
+import { $or } from "#operators.js";
+import { hasClauses } from "./hasClauses.js";
+describe("hasClauses", () => {
+    test("it returns true if the clause is a value or an object with string or symbol keys", () => {
+        expect(hasClauses({ a: 1 })).toBe(true);
+        expect(hasClauses({ [$or]: [{ a: 1 }, { a: 2 }] })).toBe(true);
+    });
+    test("it returns false if the clause is null, undefined, an empty object, or a non-object value", () => {
+        expect(hasClauses(null)).toBe(false);
+        expect(hasClauses(undefined)).toBe(false);
+        expect(hasClauses({})).toBe(false);
+        expect(hasClauses("wrong")).toBe(false);
+    });
+});

package/build/util/makeTableAlias.d.ts

@@ -0,0 +1 @@
+export declare const makeTableAlias: (index: number) => string;

package/build/util/makeTableAlias.js

@@ -0,0 +1,10 @@
+export const makeTableAlias = (index) => {
+    let result = "";
+    let curr = index;
+    do {
+        const remainder = curr % 26;
+        result = String.fromCharCode("a".charCodeAt(0) + remainder) + result;
+        curr = (curr - remainder) / 26 - 1;
+    } while (curr >= 0);
+    return result;
+};

package/build/util/makeTableAlias.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/makeTableAlias.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "vitest";
+import { makeTableAlias } from "./makeTableAlias.js";
+describe("makeTableAlias", () => {
+    test.each([
+        [0, "a"],
+        [1, "b"],
+        [26, "aa"],
+        [27, "ab"],
+        [51, "az"],
+        [52, "ba"],
+        [104, "da"],
+        [105, "db"],
+        [42000, "bjck"],
+        [42001, "bjcl"],
+    ])("tableAlias(%s) => %s", (index, expected) => {
+        expect(makeTableAlias(index)).toEqual(expected);
+    });
+});

package/build/util/resultSchema.d.ts

@@ -0,0 +1,10 @@
+import { ZodType } from "zod";
+import { NormalizedConfig, NormalizedModelDefinition } from "@casekit/orm-config";
+import { ModelDefinition, OperatorDefinitions } from "@casekit/orm-schema";
+import { FindParams } from "../types/FindParams.js";
+import { ReturningClause } from "../types/ReturningClause.js";
+export declare const resultFields: (model: NormalizedModelDefinition, fields: string[]) => Record<string, ZodType>;
+export declare const findOneResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodType;
+export declare const findManyResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodType;
+export declare const returningOneResultSchema: (model: NormalizedModelDefinition, fields?: string[]) => ZodType;
+export declare const returningManyResultSchema: (model: NormalizedModelDefinition, returning?: ReturningClause<ModelDefinition>) => ZodType;

package/build/util/resultSchema.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { getRelation, } from "@casekit/orm-config";
+export const resultFields = (model, fields) => {
+    const obj = {};
+    fields.forEach((f) => {
+        const field = model.fields[f];
+        obj[f] = field.nullable
+            ? field.zodSchema.nullish().default(null)
+            : field.zodSchema;
+    });
+    return obj;
+};
+export const findOneResultSchema = (config, m, query) => {
+    const model = config.models[m];
+    const obj = resultFields(model, query.select);
+    for (const [relationName, subquery] of Object.entries(query.include ?? {})) {
+        const relation = getRelation(model, relationName);
+        const schema = findOneResultSchema(config, relation.model, subquery);
+        if (relation.type === "N:1") {
+            obj[relationName] = relation.optional
+                ? schema.nullish().default(null)
+                : schema;
+        }
+        else {
+            obj[relationName] = z.array(schema);
+        }
+    }
+    return z.object(obj);
+};
+export const findManyResultSchema = (config, m, query) => {
+    return z.array(findOneResultSchema(config, m, query));
+};
+export const returningOneResultSchema = (model, fields) => {
+    return fields
+        ? z.object(resultFields(model, fields)).nullable()
+        : z.number();
+};
+export const returningManyResultSchema = (model, returning) => {
+    return returning
+        ? z.array(z.object(resultFields(model, returning)))
+        : z.number();
+};

package/build/util/rowToObject.d.ts

@@ -0,0 +1,8 @@
+export type Column = {
+    path: string[];
+    alias: string;
+};
+export type Join = {
+    path: string[];
+};
+export declare const rowToObject: (row: Record<string, unknown>, columns: Column[]) => Record<string, unknown>;

package/build/util/rowToObject.js

@@ -0,0 +1,10 @@
+import { set } from "es-toolkit/compat";
+export const rowToObject = (row, columns) => {
+    const obj = {};
+    for (const c of columns) {
+        if (row[c.alias] !== null) {
+            set(obj, c.path, row[c.alias]);
+        }
+    }
+    return obj;
+};

package/build/util/rowToObject.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/rowToObject.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "vitest";
+import { rowToObject } from "./rowToObject.js";
+const columns = [
+    {
+        alias: "a_0",
+        name: "id",
+        path: ["id"],
+        table: "a",
+    },
+    {
+        alias: "a_1",
+        name: "title",
+        path: ["title"],
+        table: "a",
+    },
+    {
+        alias: "a_2",
+        name: "content",
+        path: ["content"],
+        table: "a",
+    },
+    {
+        alias: "b_0",
+        name: "id",
+        path: ["author", "id"],
+        table: "b",
+    },
+    {
+        alias: "b_1",
+        name: "name",
+        path: ["author", "name"],
+        table: "b",
+    },
+    {
+        alias: "c_0",
+        name: "id",
+        path: ["author", "bio", "id"],
+        table: "c",
+    },
+    {
+        alias: "c_1",
+        name: "content",
+        path: ["author", "bio", "content"],
+        table: "c",
+    },
+];
+describe("rowToObject", () => {
+    test("it converts a flat row with column aliases into a nested object with original field names", () => {
+        expect(rowToObject({
+            a_0: 3,
+            a_1: "hello it me",
+            a_2: "a very long blog post",
+            b_0: 2,
+            b_1: "russell",
+            c_0: 5,
+            c_1: "i'm russell",
+        }, columns)).toEqual({
+            id: 3,
+            title: "hello it me",
+            content: "a very long blog post",
+            author: {
+                id: 2,
+                name: "russell",
+                bio: { id: 5, content: "i'm russell" },
+            },
+        });
+    });
+});

package/package.json

@@ -1,58 +1,66 @@
 {
   "name": "@casekit/orm",
-  "version": "0.0.1-alpha.8",
-  "description": "A simple ORM",
-  "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.js",
-  "keywords": [],
+  "description": "",
+  "version": "0.0.1-release-candidate",
   "author": "",
-  "license": "ISC",
+  "dependencies": {
+    "es-toolkit": "^1.39.3",
+    "object-hash": "^3.0.0",
+    "pino": "^9.7.0",
+    "uuid": "^11.1.0",
+    "@casekit/orm-config": "0.0.1-release-candidate",
+    "@casekit/orm-schema": "0.0.1-release-candidate",
+    "@casekit/sql": "0.0.1-release-candidate",
+    "@casekit/toolbox": "0.0.1-release-candidate"
+  },
   "devDependencies": {
-    "@anatine/zod-mock": "^3.13.4",
-    "@casekit/unindent": "^1.0.3",
-    "@faker-js/faker": "^8.4.1",
-    "@fast-check/vitest": "^0.1.0",
-    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
-    "@types/lodash-es": "^4.17.12",
+    "@casekit/unindent": "^1.0.5",
+    "@eslint/js": "^9.29.0",
+    "@faker-js/faker": "^9.8.0",
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^24.0.3",
     "@types/object-hash": "^3.0.6",
-    "@types/pg": "^8.11.5",
-    "@types/pg-format": "^1.0.5",
-    "@types/pluralize": "^0.0.33",
-    "@types/uuid": "^9.0.8",
-    "@typescript-eslint/eslint-plugin": "^7.7.0",
-    "@vitest/coverage-istanbul": "^1.4.0",
-    "@vitest/coverage-v8": "^1.4.0",
-    "@vitest/ui": "^1.4.0",
-    "dotenv": "^16.4.5",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.1",
-    "fast-check": "^3.17.1",
-    "typescript": "^5.4.5",
-    "vite-tsconfig-paths": "^4.3.2",
-    "vitest": "^1.4.0"
+    "@types/pg": "^8.15.4",
+    "@types/uuid": "^10.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^16.5.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.4.0",
+    "ts-essentials": "^10.1.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4",
+    "@casekit/orm-fixtures": "0.0.1-release-candidate",
+    "@casekit/orm-testing": "0.0.1-release-candidate",
+    "@casekit/tsconfig": "0.0.1-release-candidate",
+    "@casekit/prettier-config": "0.0.1-release-candidate"
   },
-  "dependencies": {
-    "lodash-es": "^4.17.21",
-    "object-hash": "^3.0.0",
-    "pg": "^8.11.5",
-    "pg-format": "^1.0.4",
-    "pino": "^8.20.0",
-    "pluralize": "^8.0.0",
-    "prettier": "^3.2.5",
-    "ts-toolbelt": "^9.6.0",
-    "uuid": "^9.0.1",
-    "zod": "^3.22.4"
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^4.0.17"
   },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
   "scripts": {
-    "build": "rm -rf lib && tsc",
-    "check:all": "CI=true pnpm test && CI=true pnpm lint && CI=true pnpm prettier && CI=true pnpm typecheck",
-    "lint": "eslint --ignore-path .gitignore --cache --cache-location ./node_modules/.cache/eslint .",
-    "prettier": "prettier -c src",
-    "prettier:write": "prettier -w src",
-    "release": "pnpm build && pnpm version --prerelease --preid=alpha && pnpm publish",
-    "test": "vitest --typecheck",
-    "test:coverage": "vitest --typecheck --coverage",
+    "build": "rm -rf ./build && tsc",
+    "build:watch": "tsc --watch",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck --coverage",
+    "test:watch": "vitest --typecheck",
     "typecheck": "tsc --noEmit"
   }
 }

package/.env

@@ -1,2 +0,0 @@
-PGDATABASE=orm
-PGPASSWORD=password

package/.eslintrc.cjs

@@ -1,69 +0,0 @@
-/** @type {import('eslint').Linter.Config} */
-module.exports = {
-    root: true,
-    parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        ecmaFeatures: {
-            jsx: true,
-        },
-    },
-    env: {
-        browser: true,
-        commonjs: true,
-        es6: true,
-    },
-
-    // Base config
-    extends: ["eslint:recommended"],
-
-    ignorePatterns: ["vitest.config.ts"],
-
-    overrides: [
-        // Typescript
-        {
-            files: ["**/*.{ts,tsx}"],
-            plugins: ["@typescript-eslint", "import"],
-            parser: "@typescript-eslint/parser",
-            parserOptions: {
-                project: "./tsconfig.json",
-                tsconfigRootDir: "./",
-            },
-            settings: {
-                "import/internal-regex": "^~/",
-                "import/resolver": {
-                    node: {
-                        extensions: [".ts", ".tsx"],
-                    },
-                    typescript: {
-                        alwaysTryTypes: true,
-                    },
-                },
-            },
-            extends: [
-                "plugin:@typescript-eslint/recommended",
-                "plugin:import/recommended",
-                "plugin:import/typescript",
-            ],
-            rules: {
-                "@typescript-eslint/no-unused-vars": [
-                    "error",
-                    {
-                        argsIgnorePattern: "^_",
-                        varsIgnorePattern: "^_",
-                        caughtErrorsIgnorePattern: "^_",
-                    },
-                ],
-                "@typescript-eslint/no-floating-promises": "error",
-            },
-        },
-
-        // Node
-        {
-            files: [".eslintrc.cjs"],
-            env: {
-                node: true,
-            },
-        },
-    ],
-};

package/.github/actions/ci-setup/action.yml

@@ -1,19 +0,0 @@
-name: CI setup
-runs:
-    using: composite
-    steps:
-        - uses: pnpm/action-setup@v3
-          name: Install pnpm
-          with:
-              version: 8
-              run_install: false
-
-        - uses: actions/setup-node@v4
-          with:
-              node-version: 21
-              cache: pnpm
-              registry-url: "https://registry.npmjs.org"
-
-        - name: Install dependencies
-          run: pnpm install
-          shell: bash

package/.github/dependabot.yml

@@ -1,12 +0,0 @@
-version: 2
-updates:
-    - package-ecosystem: "npm"
-      directory: "/"
-      open-pull-requests-limit: 25
-      schedule:
-          interval: "daily"
-    - package-ecosystem: "github-actions"
-      directory: "/"
-      open-pull-requests-limit: 25
-      schedule:
-          interval: "daily"

package/.github/workflows/ci.yml

@@ -1,119 +0,0 @@
-name: CI
-on:
-    push:
-        branches: [main]
-    pull_request:
-        branches: [main]
-permissions:
-    contents: write
-
-jobs:
-    test:
-        name: "🧪 Run tests"
-        timeout-minutes: 10
-        runs-on: ubuntu-latest
-        env:
-            PGUSER: casekit
-            PGPASSWORD: password
-            PGDATABASE: orm
-        services:
-            postgres:
-                image: postgres
-                env:
-                    POSTGRES_USER: ${{ env.PGUSER }}
-                    POSTGRES_PASSWORD: ${{ env.PGPASSWORD }}
-                    POSTGRES_DB: ${{ env.PGDATABASE }}
-                options: >-
-                    --health-cmd pg_isready
-                    --health-interval 10s
-                    --health-timeout 5s
-                    --health-retries 5
-                ports:
-                    - 5432:5432
-        steps:
-            - uses: actions/checkout@v4
-            - uses: ./.github/actions/ci-setup
-
-            - name: Run tests
-              run: pnpm test:coverage
-
-            - name: Upload coverage reports to Codecov
-              uses: codecov/codecov-action@v4.3.0
-              if: ${{ github.actor != 'dependabot[bot]' }}
-              with:
-                  token: ${{ secrets.CODECOV_TOKEN }}
-                  slug: casekit/orm
-
-    typecheck:
-        name: "📐 Typecheck"
-        timeout-minutes: 10
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: ./.github/actions/ci-setup
-            - name: Typecheck
-              run: pnpm typecheck
-
-    lint:
-        name: "🧹 Run eslint"
-        timeout-minutes: 10
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: ./.github/actions/ci-setup
-            - name: Lint
-              run: pnpm lint
-
-    prettier:
-        name: "💅 Run prettier"
-        timeout-minutes: 10
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: ./.github/actions/ci-setup
-            - name: Prettier
-              run: pnpm prettier
-
-    publish:
-        name: "🔥 Publish"
-        needs: [test, typecheck, lint, prettier]
-        runs-on: ubuntu-latest
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
-        steps:
-            - uses: actions/checkout@v4
-            - name: Set up Git config
-              run: |
-                  git config user.name "$(git log -n 1 --pretty=format:%an)"
-                  git config user.email "$(git log -n 1 --pretty=format:%ae)"
-            - uses: ./.github/actions/ci-setup
-            - name: Build
-              run: pnpm build
-            - name: Version
-              run: pnpm version prerelease --preid=alpha
-            - name: Publish
-              run: pnpm publish
-              env:
-                  NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-            - name: Push
-              run: git push
-            - name: Push tag
-              run: git push --tags
-
-    dependabot:
-        name: "🤖 Dependabot"
-        needs: [test, typecheck, lint, prettier]
-        runs-on: ubuntu-latest
-        if: ${{ github.actor == 'dependabot[bot]' && github.event_name == 'pull_request'}}
-        steps:
-            - name: Fetch Dependabot metadata
-              id: dependabot-metadata
-              uses: dependabot/fetch-metadata@v2
-              with:
-                  alert-lookup: true
-                  github-token: ${{ secrets.DEPENDABOT_METADATA_PAT }}
-            - name: Enable auto-merge for Dependabot Security Updates
-              run: gh pr merge --auto --squash "$PR_URL"
-              env:
-                  PR_URL: ${{ github.event.pull_request.html_url }}
-                  GITHUB_TOKEN: ${{ secrets.DEPENDABOT_MERGE_PAT }}
-              if: ${{ steps.dependabot-metadata.outputs.cvss != 0 }}