@formancy/data-sqlserver 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,115 @@
+import { DatabaseAdapter, DiscoveryScope, LookupAdapter, MetadataSnapshot, RecordAdapter } from "@formancy/data-core";
+import { ConnectionPool } from "mssql";
+//#region src/adapter.d.ts
+/**
+ * SQL Server, through a pool the composition root connected.
+ *
+ * The pool rather than a connection string: opening the connection is where a
+ * secret is handled, and that happens once, in the composition root, where the
+ * secret resolver lives. Nothing in this package reads configuration, and the
+ * tests hand it a pool pointed at a container.
+ *
+ * `ConnectionPool` is in this signature, which is why `@types/mssql` is a
+ * dependency of this package and not a devDependency: a consumer type-checking
+ * against the published declarations needs it, and `skipLibCheck` would not
+ * save them, since the import is in OUR declaration file. The install gate
+ * runs with `skipLibCheck` off for exactly this.
+ */
+export declare function createSqlServerAdapter(pool: ConnectionPool): DatabaseAdapter;
+//#endregion
+//#region src/discovery/discover.d.ts
+/**
+ * What this connection's account can see of the tables and views in `scope`,
+ * what it may do with each column, whether a security policy filters each
+ * object for it -- and, as gaps, what it cannot establish (0007, 0027) --
+ * whether it may delete from each, and every key it can see that refers to
+ * each, from any schema (0049).
+ *
+ * Read from SQL Server's catalog views, never INFORMATION_SCHEMA, which carries
+ * neither the trust and disable flags of a key nor rowversion nor extended
+ * properties (0004). One catalog concern per query, each bound to the scope by
+ * parameters; they run side by side and are not one consistent read. A
+ * concurrent ALTER can tear the result, in which case createSnapshot refuses
+ * what no catalog could produce, or drift review sees the change next time.
+ * A column and its privileges are one read (access.ts), so no column lacks
+ * an answer; a concurrent rename can still make that answer a false "no".
+ *
+ * Unlike PostgreSQL's, this catalog is filtered by permission: an object the
+ * account holds nothing on is absent, behind a schema gap, a security policy
+ * it cannot see leaves row security `unknown`, behind a scope gap, and a key
+ * on a table it cannot see is missing from what refers to a table, behind
+ * another. A graph edge constraint, which is not a foreign key, is a gap on
+ * each node table it connects, for any account (referenced-by.ts).
+ *
+ * The pool is the caller's. Nothing here opens a connection or reads
+ * configuration, and nothing here closes the pool.
+ */
+export declare function discoverSqlServer(pool: ConnectionPool, scope: DiscoveryScope): Promise<MetadataSnapshot>;
+//#endregion
+//#region src/lookups/lookups.d.ts
+/**
+ * The lookup half of the SQL Server adapter, through a pool the composition
+ * root connected.
+ *
+ * Every answer is decided by `@formancy/data-core`'s helpers — which tokens
+ * are asked about, how a page knows there is more, when a token is a member —
+ * and this only queries. The filters are read with `rowFilterTerms` before
+ * anything is built, so a request without a policy fails instead of seeing
+ * every row, and they are part of the same statement as the rest.
+ *
+ * What SQL Server decides on its own, and the adapter does not hide: how a
+ * search matches and how text orders is the column's collation, so on a
+ * case-insensitive database a search for `muster` finds `Muster AG` and
+ * `apple` sorts before `Banana`; and equality ignores trailing spaces, which
+ * is why membership is the re-encoded row's and never the database's match
+ * (0012). A filter is the exception: it compares the column's canonical value
+ * with its trusted value exactly — case, accents and trailing spaces count —
+ * as PostgreSQL's does, and still seeks an nvarchar column's index
+ * (../sql/filters.ts, 0028). A label is the record reader's value, spelled by
+ * `displayText`, so it reads the same on both engines.
+ *
+ * A database error propagates: a lookup that cannot answer refuses, and
+ * formancy turns that into a refused submission.
+ *
+ * Every statement runs until the caller's signal aborts, and is then stopped
+ * in the database by `request.cancel()`, a TDS attention (0061,
+ * ../sql/statement.ts). A signal already aborted is refused before the
+ * filters are read or a key is parsed, so a request already gone costs
+ * nothing. The pool is the one records use: an attention travels on the
+ * statement's own connection, so unlike PostgreSQL's cancel request it
+ * cannot stop anyone else's statement. No per-request `requestTimeout` is
+ * set; mssql's default of 15 s, which it hands tedious for every request
+ * (lib/tedious/connection-pool.js), still bounds every statement.
+ */
+export declare function createSqlServerLookups(pool: ConnectionPool): LookupAdapter;
+//#endregion
+//#region src/records/records.d.ts
+export declare function createSqlServerRecords(pool: ConnectionPool): RecordAdapter;
+//#endregion
+//#region src/connect.d.ts
+interface SqlServerConnectOptions {
+  host: string;
+  port: number;
+  database: string;
+  user: string;
+  password: string;
+  /** TLS. The composition root decides; there is no default here to forget. */
+  encrypt: boolean;
+  trustServerCertificate: boolean;
+}
+/**
+ * A connected pool, from this package's own copy of mssql.
+ *
+ * Why the adapter package opens its own connections: mssql's parameter types
+ * are objects tedious checks by identity, and this package binds every value
+ * with `mssql.NVarChar` and friends from ITS copy. A pool built from another
+ * copy — two installs of mssql@12.7.4 that differ only in which supports-color
+ * satisfied an optional peer, which is exactly what pnpm produced for the
+ * server — refuses every parameter with "type.validate is not a function".
+ * Found by the end-to-end suite; no unit test could see it. Opening the pool
+ * here means the pool and the types always come from one copy.
+ */
+export declare function connectSqlServer(options: SqlServerConnectOptions): Promise<ConnectionPool>;
+//#endregion
+export type { SqlServerConnectOptions };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/adapter.ts","../src/discovery/discover.ts","../src/lookups/lookups.ts","../src/records/records.ts","../src/connect.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAmBgB,uBAAuB,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBCuBxC,kBAAkB,MAAM,gBAAgB,OAAO,iBAAiB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBCsC9E,uBAAuB,MAAM,iBAAiB;;;wBCyD9C,uBAAuB,MAAM,iBAAiB;;;UCtI7C;EACf;EACA;EACA;EACA;EACA;;EAEA;EACA;;;;;;;;;;;;;;wBAec,iBAAiB,SAAS,0BAA0B,QAAQ"}