@lakeql/adapter-fabric 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/adapter.d.mts

@@ -0,0 +1,168 @@
+/**
+ * Fabric adapter core: `FabricDataSource` implementation,
+ * `fabricAdapterFactory`, and `fabricAdapterDefinition`.
+ *
+ * @module
+ */
+import { validateFabricConfig } from "./config.mjs";
+import { AdapterFactory, ColumnInfo, DataSource, DataSourceCapabilities, QueryProps, SourceConfig, TableDefinition } from "@lakeql/datasource";
+import { FabricClient } from "@lakeql/fabric-client";
+/**
+ * Capabilities declared by every `FabricDataSource` instance.
+ *
+ * The first adapter slice supports query, stream (simulated), and all
+ * metadata discovery. DDL and write are explicitly unsupported.
+ */
+declare const FABRIC_CAPABILITIES: DataSourceCapabilities;
+/**
+ * Fabric implementation of the adapter-neutral {@link DataSource}
+ * contract.
+ *
+ * Constructed exclusively through `fabricAdapterFactory.createDataSource()`.
+ * The class holds a single {@link FabricClient} and the runtime
+ * data-source name for error context.
+ */
+declare class FabricDataSource implements DataSource {
+  readonly adapter: "fabric";
+  readonly capabilities: DataSourceCapabilities;
+  readonly typeMapper: import("@lakeql/datasource").TypeMapper;
+  /** @internal */
+  private readonly client;
+  /** @internal */
+  private readonly dataSourceName;
+  /** Tracks whether {@link close} has been called. */
+  private closed;
+  constructor(client: FabricClient, dataSourceName: string);
+  /**
+   * Execute a client operation with unified error classification.
+   * All errors are passed through `classifyFabricError()`.
+   */
+  private executeWithErrorHandling;
+  /** Throw if the data source has been closed. */
+  private assertNotClosed;
+  /**
+   * Extracts a bearer token from query options for OBO flow.
+   *
+   * @returns The bearer token string, or `undefined` if not provided.
+   */
+  private static extractBearerToken;
+  /**
+   * Executes a SQL query and returns all rows as keyed records.
+   *
+   * Fabric's TDS driver returns rows as keyed objects natively,
+   * so no row-zipper transform is needed.
+   */
+  query<TRow>(props: QueryProps): Promise<TRow[]>;
+  /**
+   * Executes a SQL query and returns rows as an asynchronous generator.
+   *
+   * Fabric does not support native streaming — this simulates it by
+   * running a full query and yielding rows one at a time.
+   */
+  stream<TRow>(props: QueryProps): Promise<AsyncGenerator<TRow>>;
+  /**
+   * Lists all catalogs (databases) visible to the current connection.
+   *
+   * Queries `sys.databases` and filters out system databases.
+   */
+  catalogs(): Promise<string[]>;
+  /**
+   * Lists schemas within the given catalog.
+   *
+   * Queries `INFORMATION_SCHEMA.SCHEMATA` with a bracket-quoted catalog
+   * identifier.
+   *
+   * @param catalog - The catalog whose schemas to list.
+   */
+  schemas(catalog: string): Promise<string[]>;
+  /**
+   * Lists base tables within the given catalog and schema.
+   *
+   * Queries `INFORMATION_SCHEMA.TABLES` with a bracket-quoted catalog
+   * identifier and an escaped schema literal.
+   *
+   * @param catalog - The catalog to query.
+   * @param schema  - The schema to filter on.
+   */
+  tables(catalog: string, schema: string): Promise<string[]>;
+  /**
+   * Lists views within the given catalog and schema.
+   *
+   * Queries `INFORMATION_SCHEMA.TABLES` with a bracket-quoted catalog
+   * identifier, an escaped schema literal, and the `VIEW` predicate.
+   *
+   * @param catalog - The catalog to query.
+   * @param schema  - The schema to filter on.
+   */
+  views(catalog: string, schema: string): Promise<string[]>;
+  /**
+   * Lists columns for the given fully-qualified table.
+   *
+   * Queries `INFORMATION_SCHEMA.COLUMNS` with bracket-quoted catalog
+   * and escaped schema/table literals.
+   *
+   * @param catalog - The catalog containing the table.
+   * @param schema  - The schema containing the table.
+   * @param table   - The table whose columns to list.
+   */
+  columns(catalog: string, schema: string, table: string): Promise<ColumnInfo[]>;
+  /**
+   * Not supported by Fabric adapter. Always throws
+   * {@link UnsupportedOperationError}.
+   */
+  createTable(_definition: TableDefinition): Promise<void>;
+  /**
+   * Not supported by Fabric adapter. Always throws
+   * {@link UnsupportedOperationError}.
+   */
+  dropTable(_catalog: string, _schema: string, _table: string): Promise<void>;
+  /**
+   * Returns a safely bracket-quoted Fabric qualified table name.
+   *
+   * Applies {@link quoteIdentifier} independently to each of the three
+   * segments (`catalog`, `schema`, `tableName`) and joins them with dots.
+   *
+   * @param config - Source configuration with catalog, schema, and tableName.
+   * @returns The bracket-quoted qualified identifier, e.g. `[catalog].[schema].[table]`.
+   * @throws {Error} If any segment is empty or contains control characters.
+   */
+  qualifiedTableName(config: SourceConfig): string;
+  /**
+   * Closes the underlying Fabric client connection.
+   *
+   * Subsequent calls resolve immediately without invoking `close()` again.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Fabric adapter factory implementing the neutral {@link AdapterFactory}
+ * contract.
+ *
+ * The factory is stateless: it retains no mutable per-data-source state
+ * between calls to `createDataSource()`, `createReadStrategy()`, and
+ * `createWriteStrategy()`. All construction methods are synchronous and
+ * do not perform network requests, metadata discovery, hidden global
+ * registration, or environment lookup.
+ */
+export declare const fabricAdapterFactory: AdapterFactory;
+/**
+ * Typed-config registration value compatible with
+ * `AdapterDefinition<"fabric", FabricConnectionConfig>` from `@lakeql/config`
+ * through structural typing.
+ *
+ * The adapter package does NOT import or depend on `@lakeql/config`. This
+ * definition is consumed by `defineConfig()` to provide compile-time
+ * connection-shape inference for Fabric data sources.
+ *
+ * Intentionally omits `registrationOptions` and `mergeDataSourceConfig`
+ * because Fabric receives a complete explicit connection payload.
+ */
+export declare const fabricAdapterDefinition: {
+  /** Literal adapter name for typed narrowing. */
+  readonly adapterName: "fabric";
+  /** The exact adapter factory instance. */
+  readonly factory: AdapterFactory;
+  /** The shared assertion-style config validator. */
+  readonly validateDataSourceConfig: typeof validateFabricConfig;
+};
+export { FABRIC_CAPABILITIES, FabricDataSource };

package/dist/adapter.mjs

@@ -0,0 +1 @@
+import{validateFabricConfig as e}from"./config.mjs";import{ADAPTER_NAME as t}from"./constants.mjs";import{fabricDialect as n}from"./dialect.mjs";import{classifyFabricError as r}from"./errors.mjs";import{fabricResponseNormalizer as i}from"./normalizer.mjs";import{escapeLiteral as a,quoteIdentifier as o,quoteQualifiedIdentifier as s}from"./sql-helpers.mjs";import{fabricTypeMapper as c}from"./type-mapper.mjs";import{QueryExecutionError as l,UnsupportedOperationError as u,UnsupportedWriteStrategy as d}from"@lakeql/datasource";import{FabricClient as f}from"@lakeql/fabric-client";import{createSqlReadStrategy as p}from"@lakeql/sql-read-strategy";const m={query:!0,stream:!0,metadata:{catalogs:!0,schemas:!0,tables:!0,views:!0,columns:!0},write:{supported:!1,modes:[]},ddl:{createTable:!1,dropTable:!1}},h=[`sys`,`INFORMATION_SCHEMA`,`guest`,`queryinsights`,`_rsc`];var g=class e{adapter=t;capabilities=m;typeMapper=c;client;dataSourceName;closed=!1;constructor(e,t){this.client=e,this.dataSourceName=t}async executeWithErrorHandling(e){try{return await e()}catch(e){throw r(e,this.dataSourceName)}}assertNotClosed(){if(this.closed)throw new l(`DataSource is closed`,t,this.dataSourceName)}static extractBearerToken(e){if(e.requestAuth!==void 0){if(e.requestAuth.type===`bearer`)return e.requestAuth.token;if(e.requestAuth.type===`oauth2`)return e.requestAuth.accessToken}}async query(t){this.assertNotClosed();let n=e.extractBearerToken(t);return this.executeWithErrorHandling(async()=>this.client.query({sql:t.sql,signal:t.signal,bearerToken:n}))}async stream(e){this.assertNotClosed();let t=await this.query(e);async function*n(){for(let e of t)yield e}return n()}async catalogs(){return this.assertNotClosed(),this.executeWithErrorHandling(async()=>(await this.client.query({sql:`SELECT name FROM sys.databases WHERE name NOT IN ('master', 'tempdb', 'model', 'msdb') ORDER BY name`})).map(e=>String(e.name)))}async schemas(e){this.assertNotClosed();let t=h.map(e=>a(e)).join(`, `),n=`SELECT schema_name FROM ${o(e)}.INFORMATION_SCHEMA.SCHEMATA WHERE schema_name NOT IN (${t}) AND schema_name NOT LIKE 'db[_]%' ORDER BY schema_name`;return this.executeWithErrorHandling(async()=>(await this.client.query({sql:n})).map(e=>String(e.schema_name)))}async tables(e,t){this.assertNotClosed();let n=`SELECT table_name FROM ${o(e)}.INFORMATION_SCHEMA.TABLES WHERE table_schema = ${a(t)} AND table_type = 'BASE TABLE' ORDER BY table_name`;return this.executeWithErrorHandling(async()=>(await this.client.query({sql:n})).map(e=>String(e.table_name)))}async views(e,t){this.assertNotClosed();let n=`SELECT table_name FROM ${o(e)}.INFORMATION_SCHEMA.TABLES WHERE table_schema = ${a(t)} AND table_type = 'VIEW' ORDER BY table_name`;return this.executeWithErrorHandling(async()=>(await this.client.query({sql:n})).map(e=>String(e.table_name)))}async columns(e,t,n){this.assertNotClosed();let r=`SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM ${o(e)}.INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ${a(t)} AND TABLE_NAME = ${a(n)} ORDER BY ORDINAL_POSITION`;return this.executeWithErrorHandling(async()=>(await this.client.query({sql:r})).map(e=>({name:String(e.COLUMN_NAME),type:String(e.DATA_TYPE),extra:e.IS_NULLABLE===`YES`?`nullable`:void 0,description:void 0})))}async createTable(e){throw this.assertNotClosed(),new u(`Fabric adapter does not support CREATE TABLE in this adapter slice`,t,this.dataSourceName,`createTable`)}async dropTable(e,n,r){throw this.assertNotClosed(),new u(`Fabric adapter does not support DROP TABLE in this adapter slice`,t,this.dataSourceName,`dropTable`)}qualifiedTableName(e){return s(e.catalog,e.schema,e.tableName)}async close(){if(!this.closed){this.closed=!0;try{await this.client.close()}catch{}}}};const _={adapterName:t,createDataSource(t,n){e(t);let r={host:t.host,port:t.port,catalog:t.catalog,auth:t.auth};return t.source!==void 0&&(r.source=t.source),new g(new f(r),n)},createReadStrategy({dataSource:e,resolveAuth:t,paging:r}){return p({dataSource:e,resolveAuth:t,dialect:n,normalizer:i,readValidation:r?{maxPerPage:r.maxRecordsPerPage}:void 0,defaultPerPage:r?.defaultPerPage})},createWriteStrategy({dataSourceName:e}){return new d({adapter:t,dataSource:e})}},v={adapterName:t,factory:_,validateDataSourceConfig:e};export{m as FABRIC_CAPABILITIES,g as FabricDataSource,v as fabricAdapterDefinition,_ as fabricAdapterFactory};

package/dist/config.d.mts

@@ -0,0 +1,63 @@
+/**
+ * OAuth2 client credentials authentication for Azure AD.
+ */
+export interface FabricOAuth2Auth {
+  type: "oauth2";
+  /** Azure AD tenant ID. */
+  tenantId: string;
+  /** Azure AD application (client) ID. */
+  clientId: string;
+  /** Azure AD client secret. */
+  clientSecret: string;
+  /** Optional scope override. */
+  scope?: string;
+}
+/**
+ * Bearer token authentication (e.g. pre-acquired OAuth2 token).
+ */
+export interface FabricBearerAuth {
+  type: "bearer";
+  /** The bearer token value. */
+  token: string;
+}
+/**
+ * Authentication credentials for a Fabric connection — either OAuth2
+ * client credentials or a static bearer token.
+ */
+export type FabricAuth = FabricOAuth2Auth | FabricBearerAuth;
+/**
+ * Configuration for connecting to a Microsoft Fabric SQL endpoint.
+ *
+ * Fields mirror `FabricClientProps` from `@lakeql/fabric-client`. The outer
+ * runtime definition owns adapter selection through its `adapter` field;
+ * this type intentionally does not include an inner adapter discriminator.
+ */
+export interface FabricConnectionConfig {
+  /** Fabric SQL endpoint hostname (e.g. `"your-endpoint.datawarehouse.fabric.microsoft.com"`). */
+  host: string;
+  /** Port the Fabric SQL endpoint listens on (typically `1433`). */
+  port: number;
+  /** Default catalog (database) for all queries. */
+  catalog: string;
+  /** Authentication credentials. */
+  auth: FabricAuth;
+  /** Source identifier for diagnostics. */
+  source?: string;
+}
+/**
+ * Assertion-style validator for {@link FabricConnectionConfig}.
+ *
+ * Validates the shape and constraints of a Fabric connection configuration
+ * payload. Throws a plain `Error` synchronously when the input is invalid.
+ * Error messages identify the offending field by name but never include
+ * client secrets, bearer tokens, or serialized configuration objects.
+ *
+ * The same implementation is used at both the `defineConfig()` boundary
+ * (via `fabricAdapterDefinition.validateDataSourceConfig`) and the
+ * `fabricAdapterFactory.createDataSource()` boundary, ensuring a single
+ * set of validation rules.
+ *
+ * @param config - The unknown value to validate.
+ * @throws {Error} When the input is not a valid `FabricConnectionConfig`.
+ */
+export declare function validateFabricConfig(config: unknown): asserts config is FabricConnectionConfig;

package/dist/config.mjs

@@ -0,0 +1 @@
+import{isPlainObject as e}from"./sql-helpers.mjs";function t(e,t){if(typeof e!=`string`||e===``)throw Error(`Invalid Fabric config: "${t}" must be a non-empty string`)}function n(n){if(!e(n))throw Error(`Invalid Fabric config: expected a non-null plain object`);t(n.host,`host`);let{port:r}=n;if(typeof r!=`number`||!Number.isFinite(r)||!Number.isInteger(r)||r<1||r>65535)throw Error(`Invalid Fabric config: "port" must be a finite integer in the range 1–65535`);if(t(n.catalog,`catalog`),!e(n.auth))throw Error(`Invalid Fabric config: "auth" must be a non-null plain object`);let{auth:i}=n,a=i.type;if(a===`oauth2`){t(i.tenantId,`auth.tenantId`),t(i.clientId,`auth.clientId`),t(i.clientSecret,`auth.clientSecret`),i.scope!==void 0&&t(i.scope,`auth.scope`);let e=/* @__PURE__ */ new Set([`type`,`tenantId`,`clientId`,`clientSecret`,`scope`]);if(Object.keys(i).filter(t=>!e.has(t)).length>0)throw Error(`Invalid Fabric config: "auth" contains unexpected fields; oauth2 auth allows only type, tenantId, clientId, clientSecret, scope`)}else if(a===`bearer`){t(i.token,`auth.token`);let e=/* @__PURE__ */ new Set([`type`,`token`]);if(Object.keys(i).filter(t=>!e.has(t)).length>0)throw Error(`Invalid Fabric config: "auth" contains unexpected fields; bearer auth allows only type, token`)}else throw Error(`Invalid Fabric config: "auth.type" must be "oauth2" or "bearer"`);n.source!==void 0&&t(n.source,`source`)}export{n as validateFabricConfig};

package/dist/constants.d.mts

@@ -0,0 +1,2 @@
+/** Adapter name literal for the Fabric adapter. Used across all modules. */
+export declare const ADAPTER_NAME: "fabric";

package/dist/constants.mjs

@@ -0,0 +1 @@
+const e=`fabric`;export{e as ADAPTER_NAME};

package/dist/dialect.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Fabric-specific {@link QueryDialect} implementation using Kysely components.
+ *
+ * Provides T-SQL–specific SQL generation hooks: MSSQL-compatible Kysely
+ * components for query compilation, `DATEDIFF(SECOND, ...)` for date
+ * conversion, `OFFSET/FETCH` for pagination, and bracket-quoted
+ * identifier quoting.
+ *
+ * @module
+ */
+import { QueryDialect } from "@lakeql/query-builder";
+/**
+ * Fabric query dialect implementing the neutral {@link QueryDialect} contract.
+ *
+ * Uses Kysely's MSSQL adapter/compiler since Fabric's SQL dialect is
+ * T-SQL. The dialect provides Fabric-specific SQL fragments for
+ * timestamp conversion, pagination, and identifier quoting.
+ */
+export declare const fabricDialect: QueryDialect;

package/dist/dialect.mjs

@@ -0,0 +1 @@
+import{ADAPTER_NAME as e}from"./constants.mjs";import{quoteQualifiedIdentifier as t}from"./sql-helpers.mjs";import{MssqlAdapter as n,MssqlIntrospector as r,MssqlQueryCompiler as i,sql as a}from"kysely";const o={adapterName:e,createAdapter:()=>new n,createQueryCompiler:()=>new i,createIntrospector:e=>new r(e),toUnixTimestamp:e=>a.raw(`DATEDIFF(SECOND, '1970-01-01', ${e})`),pagination:(e,t)=>a.raw(`OFFSET ${t??0} ROWS FETCH NEXT ${e} ROWS ONLY`),trueLiteral:()=>a.raw(`1`),qualifiedTable:e=>t(e.catalog,e.schema,e.tableName)};export{o as fabricDialect};

package/dist/errors.d.mts

@@ -0,0 +1,18 @@
+import { DataSourceError } from "@lakeql/datasource";
+/**
+ * Classify a Fabric client error into the shared {@link DataSourceError}
+ * hierarchy.
+ *
+ * The classifier always sets `adapter` to `"fabric"` and preserves the
+ * original error as `cause`. Error messages are bounded and
+ * credential-safe — they never include passwords, tokens,
+ * authorization headers, raw SQL, or complete request options.
+ *
+ * Already-classified {@link DataSourceError} instances are returned
+ * unchanged with strict reference identity (no double-wrapping).
+ *
+ * @param error - The caught error value (may be any type).
+ * @param dataSource - Runtime name of the data source for error context.
+ * @returns A concrete {@link DataSourceError} subclass instance.
+ */
+export declare function classifyFabricError(error: unknown, dataSource: string): DataSourceError;

package/dist/errors.mjs

@@ -0,0 +1 @@
+import{ADAPTER_NAME as e}from"./constants.mjs";import{AuthenticationError as t,CancellationError as n,DataSourceError as r,NetworkError as i,QueryExecutionError as a,TimeoutError as o}from"@lakeql/datasource";import{FabricCancellationError as s,FabricClientError as c,FabricQueryError as l,FabricTimeoutError as u}from"@lakeql/fabric-client";function d(d,f){if(d instanceof r)return d;let p={cause:d};if(d instanceof l)return new a(`Fabric query failed: error ${d.errorNumber} (state ${d.state})`,e,f,p);if(d instanceof c){let n=d.statusCode;return n===401||n===403?new t(`Fabric authentication failed (HTTP ${n})`,e,f,p):n===408||n===504?new o(`Fabric request timed out (HTTP ${n})`,e,f,p):n===void 0||n===0?new i(`Fabric network error: no response received`,e,f,p):new a(`Fabric client error (HTTP ${n})`,e,f,p)}if(d instanceof u)return new o(`Fabric query timed out`,e,f,p);if(d instanceof s)return new n(`Fabric query was cancelled`,e,f,p);if(d instanceof DOMException){if(d.name===`TimeoutError`)return new o(`Fabric request timed out`,e,f,p);if(d.name===`AbortError`)return new n(`Fabric request was aborted`,e,f,p)}if(d instanceof TypeError)return new i(`Fabric network error`,e,f,p);let m=d instanceof DOMException?`Fabric unexpected DOMException: ${d.name}`:`Fabric unknown error`;return new a(m,e,f,p)}export{d as classifyFabricError};

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+/** Fabric adapter factory implementing the neutral AdapterFactory contract. */
+import { fabricAdapterDefinition, fabricAdapterFactory } from "./adapter.mjs";
+import { ADAPTER_NAME } from "./constants.mjs";
+import { FabricAuth, FabricBearerAuth, FabricConnectionConfig, FabricOAuth2Auth, validateFabricConfig } from "./config.mjs";
+import { classifyFabricError } from "./errors.mjs";
+import { fabricDialect } from "./dialect.mjs";
+import { fabricResponseNormalizer } from "./normalizer.mjs";
+import { fabricTypeMapper } from "./type-mapper.mjs";
+export { ADAPTER_NAME, type FabricAuth, type FabricBearerAuth, type FabricConnectionConfig, type FabricOAuth2Auth, classifyFabricError, fabricAdapterDefinition, fabricAdapterFactory, fabricDialect, fabricResponseNormalizer, fabricTypeMapper, validateFabricConfig };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{fabricAdapterDefinition as e,fabricAdapterFactory as t}from"./adapter.mjs";import{ADAPTER_NAME as n}from"./constants.mjs";import{validateFabricConfig as r}from"./config.mjs";import{classifyFabricError as i}from"./errors.mjs";import{fabricDialect as a}from"./dialect.mjs";import{fabricResponseNormalizer as o}from"./normalizer.mjs";import{fabricTypeMapper as s}from"./type-mapper.mjs";export{n as ADAPTER_NAME,i as classifyFabricError,e as fabricAdapterDefinition,t as fabricAdapterFactory,a as fabricDialect,o as fabricResponseNormalizer,s as fabricTypeMapper,r as validateFabricConfig};

package/dist/normalizer.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Fabric-specific {@link ResponseNormalizer} implementation.
+ *
+ * Fabric's TDS driver returns the presence sentinel as the integer `1` rather
+ * than a boolean, so a real data row's sentinel is `true` or `1`. All other
+ * CTE decoding is shared with the Trino adapter via
+ * {@link createCteResponseNormalizer}.
+ *
+ * @module
+ */
+import { ResponseNormalizer } from "@lakeql/response-transformer";
+/**
+ * Fabric response normalizer implementing the neutral
+ * {@link ResponseNormalizer} contract. Accepts `true` or `1` as the record
+ * sentinel (T-SQL returns `1`).
+ */
+export declare const fabricResponseNormalizer: ResponseNormalizer;

package/dist/normalizer.mjs

@@ -0,0 +1 @@
+import{ADAPTER_NAME as e}from"./constants.mjs";import{isPlainObject as t}from"./sql-helpers.mjs";import{createCteResponseNormalizer as n}from"@lakeql/response-transformer";const r=n({adapterName:e,isPresentSentinel:e=>e===!0||e===1,acceptedSentinelDescription:`true/1`,isPlainObject:t});export{r as fabricResponseNormalizer};

package/dist/sql-helpers.d.mts

@@ -0,0 +1,48 @@
+/**
+ * Adapter-owned Fabric/T-SQL rendering helpers for bracket-quoted
+ * identifier quoting and literal escaping. These are used by metadata
+ * queries, DDL rendering, and the Fabric dialect throughout the adapter.
+ *
+ * @module
+ */
+import { escapeLiteral, isPlainObject } from "@lakeql/datasource";
+/**
+ * Quote a single SQL identifier segment for T-SQL using bracket quoting.
+ *
+ * The input is treated as exactly one identifier segment. Dots within the
+ * value are preserved as part of the segment and are **not** interpreted as
+ * qualification separators. Embedded right-bracket characters are escaped by
+ * doubling them (`]` → `]]`), and the result is wrapped in brackets.
+ *
+ * @param segment - The raw identifier segment to quote.
+ * @returns The safely bracket-quoted identifier string.
+ * @throws {Error} If `segment` is empty or contains C0/C1 control characters.
+ *
+ * @example
+ * ```ts
+ * quoteIdentifier("my_table") // => "[my_table]"
+ * // A literal "]" is escaped by doubling it ("]]"), per T-SQL bracket quoting:
+ * quoteIdentifier("has]bracket") // => "[has]]bracket]"
+ * // Dots stay part of the single segment, they are not treated as separators:
+ * quoteIdentifier("catalog.with.dot") // => "[catalog.with.dot]"
+ * ```
+ */
+export declare function quoteIdentifier(segment: string): string;
+/**
+ * Quote a fully-qualified T-SQL identifier composed of one or more segments.
+ *
+ * Applies {@link quoteIdentifier} independently to each segment and joins
+ * them with literal dots. Requires at least one segment.
+ *
+ * @param segments - One or more raw identifier segments (e.g. catalog, schema, table).
+ * @returns The safely quoted qualified identifier string.
+ * @throws {Error} If no segments are provided, or if any segment is invalid.
+ *
+ * @example
+ * ```ts
+ * quoteQualifiedIdentifier("warehouse", "dbo", "orders")
+ * // => '[warehouse].[dbo].[orders]'
+ * ```
+ */
+export declare function quoteQualifiedIdentifier(...segments: string[]): string;
+export { escapeLiteral, isPlainObject };

package/dist/sql-helpers.mjs

@@ -0,0 +1 @@
+import{escapeLiteral as e,isPlainObject as t,quoteQualified as n,rejectControlChars as r}from"@lakeql/datasource";function i(e){if(e.length===0)throw Error(`Identifier segment must not be empty`);return r(e,`Identifier segment`),`[${e.replaceAll(`]`,`]]`)}]`}function a(...e){return n(i,...e)}export{e as escapeLiteral,t as isPlainObject,i as quoteIdentifier,a as quoteQualifiedIdentifier};

package/dist/type-mapper.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Fabric type mapping between T-SQL / Fabric SQL types and LakeQL primitive
+ * types.
+ *
+ * @module
+ */
+/** Shared {@link TypeMapper} for Fabric / T-SQL types. */
+export declare const fabricTypeMapper: import("@lakeql/datasource").TypeMapper;

package/dist/type-mapper.mjs

@@ -0,0 +1 @@
+import{createTypeMapper as e}from"@lakeql/datasource";const t=e({toPrimitive:{nvarchar:`String`,varchar:`String`,char:`String`,nchar:`String`,text:`String`,ntext:`String`,xml:`String`,uniqueidentifier:`String`,varbinary:`String`,binary:`String`,int:`Integer`,bigint:`Integer`,smallint:`Integer`,tinyint:`Integer`,float:`Float`,real:`Float`,decimal:`Float`,numeric:`Float`,money:`Float`,smallmoney:`Float`,bit:`Boolean`,date:`Date`,datetime:`DateTime`,datetime2:`DateTime`,datetimeoffset:`DateTime`,smalldatetime:`DateTime`,time:`DateTime`},toEngine:{String:`NVARCHAR(MAX)`,Integer:`BIGINT`,Float:`FLOAT`,Boolean:`BIT`,Date:`DATE`,DateTime:`DATETIME2(3)`}});export{t as fabricTypeMapper};

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@lakeql/adapter-fabric",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Microsoft Fabric adapter for LakeQL",
+  "keywords": [
+    "adapter",
+    "fabric",
+    "lakeql",
+    "mssql"
+  ],
+  "homepage": "https://lakeql.dev",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Marcus Reinhardt",
+    "url": "https://github.com/noxify"
+  },
+  "contributors": [
+    {
+      "name": "Marcus Reinhardt",
+      "url": "https://github.com/noxify"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/noxify/lakeql",
+    "directory": "packages/adapter-fabric"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@lakeql/datasource": "1.0.0",
+    "@lakeql/fabric-client": "1.0.0",
+    "@lakeql/query-builder": "1.0.0",
+    "@lakeql/response-transformer": "1.0.0",
+    "@lakeql/sql-read-strategy": "1.0.0",
+    "kysely": "0.29.8"
+  },
+  "devDependencies": {
+    "@lakeql/tsconfig": "0.1.0",
+    "@lakeql/vitest-config": "0.1.0",
+    "@types/node": "24.19.2",
+    "tsdown": "0.23.7",
+    "typescript": "6.0.3",
+    "vitest": "5.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "git clean -xdf .cache .turbo dist node_modules dist",
+    "clean:cache": "git clean -xdf .cache .turbo",
+    "clean:dist": "git clean -xdf dist",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.