weave-typescript 0.5.1 → 0.8.0

package/dist/weavesql/llmxdb/search_sql.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelsByPriceRangeQuery = exports.getModelsByContextWindowQuery = exports.getModelsByParameterCountQuery = exports.getModelsBySafetyQuery = exports.getOpenSourceModelsQuery = exports.searchModelsByArchitectureQuery = exports.searchModelsQuery = void 0;
+exports.searchModels = searchModels;
+exports.searchModelsByArchitecture = searchModelsByArchitecture;
+exports.getOpenSourceModels = getOpenSourceModels;
+exports.getModelsBySafety = getModelsBySafety;
+exports.getModelsByParameterCount = getModelsByParameterCount;
+exports.getModelsByContextWindow = getModelsByContextWindow;
+exports.getModelsByPriceRange = getModelsByPriceRange;
+exports.searchModelsQuery = `-- name: SearchModels :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND ($1::uuid IS NULL OR provider_id = $1)
+  AND ($2::text IS NULL OR classification ->> 'model_type' = $2)
+  AND ($3::int IS NULL OR (token_info ->> 'context_window')::int >= $3)
+  AND ($4::numeric IS NULL OR (pricing ->> 'input_price')::numeric <= $4)
+  AND ($5::text IS NULL OR capabilities->'configs' ? $5)
+ORDER BY CASE WHEN $6 = 'price' THEN (pricing ->> 'input_price')::numeric END ASC,
+         CASE WHEN $6 = 'context' THEN (token_info ->> 'context_window')::int END DESC,
+         name ASC
+LIMIT $8 OFFSET $7`;
+async function searchModels(client, args) {
+    const result = await client.query({
+        text: exports.searchModelsQuery,
+        values: [args.providerId, args.modelType, args.minContext, args.maxInputPrice, args.hasCapability, args.orderBy, args.offsetCount, args.limitCount],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.searchModelsByArchitectureQuery = `-- name: SearchModelsByArchitecture :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND ($1::text IS NULL OR architecture->>'base_architecture' = $1)
+  AND ($2::bigint IS NULL OR (architecture->>'parameter_count')::bigint >= $2)
+  AND ($3::bigint IS NULL OR (architecture->>'parameter_count')::bigint <= $3)
+  AND ($4::boolean IS NULL OR (architecture->>'is_mixture_of_experts')::boolean = $4)
+ORDER BY (architecture->>'parameter_count')::bigint DESC`;
+async function searchModelsByArchitecture(client, args) {
+    const result = await client.query({
+        text: exports.searchModelsByArchitectureQuery,
+        values: [args.baseArchitecture, args.minParams, args.maxParams, args.isMoe],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.getOpenSourceModelsQuery = `-- name: GetOpenSourceModels :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND (licensing->>'is_open_source')::boolean = true
+  AND ($1::boolean IS NULL OR (licensing->>'commercial_use')::boolean = $1)
+ORDER BY provider_id, name`;
+async function getOpenSourceModels(client, args) {
+    const result = await client.query({
+        text: exports.getOpenSourceModelsQuery,
+        values: [args.commercialUse],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.getModelsBySafetyQuery = `-- name: GetModelsBySafety :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND ($1::text IS NULL OR safety->>'moderation_level' = $1)
+  AND ($2::boolean IS NULL OR (safety->>'gdpr_compliant')::boolean = $2)
+  AND ($3::boolean IS NULL OR (safety->>'hipaa_compliant')::boolean = $3)
+ORDER BY provider_id, name`;
+async function getModelsBySafety(client, args) {
+    const result = await client.query({
+        text: exports.getModelsBySafetyQuery,
+        values: [args.moderationLevel, args.gdprCompliant, args.hipaaCompliant],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.getModelsByParameterCountQuery = `-- name: GetModelsByParameterCount :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND ($1::bigint IS NULL OR (architecture->>'parameter_count')::bigint >= $1)
+  AND ($2::bigint IS NULL OR (architecture->>'parameter_count')::bigint <= $2)
+ORDER BY (architecture->>'parameter_count')::bigint DESC`;
+async function getModelsByParameterCount(client, args) {
+    const result = await client.query({
+        text: exports.getModelsByParameterCountQuery,
+        values: [args.minParams, args.maxParams],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.getModelsByContextWindowQuery = `-- name: GetModelsByContextWindow :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models  
+WHERE is_active = true
+  AND ($1::int IS NULL OR (token_info->>'context_window')::int >= $1)
+  AND ($2::int IS NULL OR (token_info->>'context_window')::int <= $2)
+ORDER BY (token_info->>'context_window')::int DESC`;
+async function getModelsByContextWindow(client, args) {
+    const result = await client.query({
+        text: exports.getModelsByContextWindowQuery,
+        values: [args.minContext, args.maxContext],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}
+exports.getModelsByPriceRangeQuery = `-- name: GetModelsByPriceRange :many
+SELECT id, provider_id, model_id, slug, name, display_name, description, version, capabilities, classification, architecture, performance, token_info, pricing, api_details, training, licensing, safety, availability, technical_specs, release_date, training_data_cutoff, deprecation_date, metadata, last_scraped_at, is_active, is_deprecated, created_at, updated_at
+FROM llm_models
+WHERE is_active = true
+  AND ($1::numeric IS NULL OR (pricing->>'input_price')::numeric <= $1)
+  AND ($2::numeric IS NULL OR (pricing->>'output_price')::numeric <= $2)
+ORDER BY (pricing->>'input_price')::numeric ASC`;
+async function getModelsByPriceRange(client, args) {
+    const result = await client.query({
+        text: exports.getModelsByPriceRangeQuery,
+        values: [args.maxInputPrice, args.maxOutputPrice],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            providerId: row[1],
+            modelId: row[2],
+            slug: row[3],
+            name: row[4],
+            displayName: row[5],
+            description: row[6],
+            version: row[7],
+            capabilities: row[8],
+            classification: row[9],
+            architecture: row[10],
+            performance: row[11],
+            tokenInfo: row[12],
+            pricing: row[13],
+            apiDetails: row[14],
+            training: row[15],
+            licensing: row[16],
+            safety: row[17],
+            availability: row[18],
+            technicalSpecs: row[19],
+            releaseDate: row[20],
+            trainingDataCutoff: row[21],
+            deprecationDate: row[22],
+            metadata: row[23],
+            lastScrapedAt: row[24],
+            isActive: row[25],
+            isDeprecated: row[26],
+            createdAt: row[27],
+            updatedAt: row[28]
+        };
+    });
+}

package/dist/weavesql/weavedb/dataset_sql.d.ts

@@ -0,0 +1,17 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const upsertDatasetQuery = "-- name: UpsertDataset :exec\nINSERT INTO generate_v1.dataset (id, organization_id, name, description, storage_connection_id, schema_id,\n                                 synthesizer_id, is_synthetic)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8)\nON CONFLICT (id) DO UPDATE SET name                  = EXCLUDED.name,\n                               description           = EXCLUDED.description,\n                               storage_connection_id = EXCLUDED.storage_connection_id,\n                               schema_id             = EXCLUDED.schema_id,\n                               synthesizer_id        = EXCLUDED.synthesizer_id,\n                               is_synthetic          = EXCLUDED.is_synthetic";
+export interface UpsertDatasetArgs {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    storageConnectionId: string;
+    schemaId: string | null;
+    synthesizerId: string | null;
+    isSynthetic: boolean | null;
+}
+export declare function upsertDataset(client: Client, args: UpsertDatasetArgs): Promise<void>;
+export {};

package/dist/weavesql/weavedb/dataset_sql.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertDatasetQuery = void 0;
+exports.upsertDataset = upsertDataset;
+exports.upsertDatasetQuery = `-- name: UpsertDataset :exec
+INSERT INTO generate_v1.dataset (id, organization_id, name, description, storage_connection_id, schema_id,
+                                 synthesizer_id, is_synthetic)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+ON CONFLICT (id) DO UPDATE SET name                  = EXCLUDED.name,
+                               description           = EXCLUDED.description,
+                               storage_connection_id = EXCLUDED.storage_connection_id,
+                               schema_id             = EXCLUDED.schema_id,
+                               synthesizer_id        = EXCLUDED.synthesizer_id,
+                               is_synthetic          = EXCLUDED.is_synthetic`;
+async function upsertDataset(client, args) {
+    await client.query({
+        text: exports.upsertDatasetQuery,
+        values: [args.id, args.organizationId, args.name, args.description, args.storageConnectionId, args.schemaId, args.synthesizerId, args.isSynthetic],
+        rowMode: "array"
+    });
+}

package/dist/weavesql/weavedb/relationships_sql.d.ts

@@ -0,0 +1,16 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const getForeignKeyRelationshipsQuery = "-- name: GetForeignKeyRelationships :many\nSELECT cr.source_dataset_id,\n       cr.target_dataset_id,\n       sc.name AS source_column_name,\n       tc.name AS target_column_name\nFROM synthesize_v1.column_relationship cr\n         JOIN\n     synthesize_v1.data_column sc ON cr.source_column_id = sc.id\n         JOIN\n     synthesize_v1.data_column tc ON cr.target_column_id = tc.id\nWHERE cr.relationship_type IN ('context_foreign_key', 'non_context_foreign_key')\n  AND cr.source_dataset_id = ANY ($1::UUID[])\n  AND cr.target_dataset_id = ANY ($1::UUID[])";
+export interface GetForeignKeyRelationshipsArgs {
+    datasetIds: string[];
+}
+export interface GetForeignKeyRelationshipsRow {
+    sourceDatasetId: string;
+    targetDatasetId: string;
+    sourceColumnName: string;
+    targetColumnName: string;
+}
+export declare function getForeignKeyRelationships(client: Client, args: GetForeignKeyRelationshipsArgs): Promise<GetForeignKeyRelationshipsRow[]>;
+export {};

package/dist/weavesql/weavedb/relationships_sql.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getForeignKeyRelationshipsQuery = void 0;
+exports.getForeignKeyRelationships = getForeignKeyRelationships;
+exports.getForeignKeyRelationshipsQuery = `-- name: GetForeignKeyRelationships :many
+SELECT cr.source_dataset_id,
+       cr.target_dataset_id,
+       sc.name AS source_column_name,
+       tc.name AS target_column_name
+FROM synthesize_v1.column_relationship cr
+         JOIN
+     synthesize_v1.data_column sc ON cr.source_column_id = sc.id
+         JOIN
+     synthesize_v1.data_column tc ON cr.target_column_id = tc.id
+WHERE cr.relationship_type IN ('context_foreign_key', 'non_context_foreign_key')
+  AND cr.source_dataset_id = ANY ($1::UUID[])
+  AND cr.target_dataset_id = ANY ($1::UUID[])`;
+async function getForeignKeyRelationships(client, args) {
+    const result = await client.query({
+        text: exports.getForeignKeyRelationshipsQuery,
+        values: [args.datasetIds],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            sourceDatasetId: row[0],
+            targetDatasetId: row[1],
+            sourceColumnName: row[2],
+            targetColumnName: row[3]
+        };
+    });
+}

package/dist/weavesql/weavedb/storage_sql.d.ts

@@ -0,0 +1,33 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const getStorageConnectionQuery = "-- name: GetStorageConnection :one\nSELECT id, organization_id, name, description, category, variant, details\nFROM storage_connection\nWHERE id = $1";
+export interface GetStorageConnectionArgs {
+    id: string;
+}
+export interface GetStorageConnectionRow {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    category: string;
+    variant: string;
+    details: any;
+}
+export declare function getStorageConnection(client: Client, args: GetStorageConnectionArgs): Promise<GetStorageConnectionRow | null>;
+export declare const getStorageConnectionByDatasetIDQuery = "-- name: GetStorageConnectionByDatasetID :one\nSELECT sc.id, sc.organization_id, sc.name, sc.description, sc.category, sc.variant, sc.details\nFROM storage_connection sc\n         JOIN generate_v1.dataset d ON d.storage_connection_id = sc.id\nWHERE d.id = $1";
+export interface GetStorageConnectionByDatasetIDArgs {
+    datasetId: string;
+}
+export interface GetStorageConnectionByDatasetIDRow {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    category: string;
+    variant: string;
+    details: any;
+}
+export declare function getStorageConnectionByDatasetID(client: Client, args: GetStorageConnectionByDatasetIDArgs): Promise<GetStorageConnectionByDatasetIDRow | null>;
+export {};

package/dist/weavesql/weavedb/storage_sql.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageConnectionByDatasetIDQuery = exports.getStorageConnectionQuery = void 0;
+exports.getStorageConnection = getStorageConnection;
+exports.getStorageConnectionByDatasetID = getStorageConnectionByDatasetID;
+exports.getStorageConnectionQuery = `-- name: GetStorageConnection :one
+SELECT id, organization_id, name, description, category, variant, details
+FROM storage_connection
+WHERE id = $1`;
+async function getStorageConnection(client, args) {
+    const result = await client.query({
+        text: exports.getStorageConnectionQuery,
+        values: [args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        name: row[2],
+        description: row[3],
+        category: row[4],
+        variant: row[5],
+        details: row[6]
+    };
+}
+exports.getStorageConnectionByDatasetIDQuery = `-- name: GetStorageConnectionByDatasetID :one
+SELECT sc.id, sc.organization_id, sc.name, sc.description, sc.category, sc.variant, sc.details
+FROM storage_connection sc
+         JOIN generate_v1.dataset d ON d.storage_connection_id = sc.id
+WHERE d.id = $1`;
+async function getStorageConnectionByDatasetID(client, args) {
+    const result = await client.query({
+        text: exports.getStorageConnectionByDatasetIDQuery,
+        values: [args.datasetId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        name: row[2],
+        description: row[3],
+        category: row[4],
+        variant: row[5],
+        details: row[6]
+    };
+}

package/dist/weavesql/weavedb/synthesizer_sql.d.ts

@@ -0,0 +1,28 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const upsertSynthesizerQuery = "-- name: UpsertSynthesizer :exec\nINSERT INTO synthesize_v1.synthesizer (id, organization_id, name, description, storage_connection_id, metadata)\nVALUES ($1, $2, $3, $4, $5, $6)\nON CONFLICT (id) DO UPDATE SET name                  = EXCLUDED.name,\n                               description           = EXCLUDED.description,\n                               storage_connection_id = EXCLUDED.storage_connection_id,\n                               metadata              = EXCLUDED.metadata";
+export interface UpsertSynthesizerArgs {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    storageConnectionId: string;
+    metadata: any | null;
+}
+export declare function upsertSynthesizer(client: Client, args: UpsertSynthesizerArgs): Promise<void>;
+export declare const getSynthesizerQuery = "-- name: GetSynthesizer :one\nSELECT id, organization_id, name, description, storage_connection_id, metadata\nFROM synthesize_v1.synthesizer\nWHERE id = $1";
+export interface GetSynthesizerArgs {
+    id: string;
+}
+export interface GetSynthesizerRow {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    storageConnectionId: string;
+    metadata: any | null;
+}
+export declare function getSynthesizer(client: Client, args: GetSynthesizerArgs): Promise<GetSynthesizerRow | null>;
+export {};

package/dist/weavesql/weavedb/synthesizer_sql.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSynthesizerQuery = exports.upsertSynthesizerQuery = void 0;
+exports.upsertSynthesizer = upsertSynthesizer;
+exports.getSynthesizer = getSynthesizer;
+exports.upsertSynthesizerQuery = `-- name: UpsertSynthesizer :exec
+INSERT INTO synthesize_v1.synthesizer (id, organization_id, name, description, storage_connection_id, metadata)
+VALUES ($1, $2, $3, $4, $5, $6)
+ON CONFLICT (id) DO UPDATE SET name                  = EXCLUDED.name,
+                               description           = EXCLUDED.description,
+                               storage_connection_id = EXCLUDED.storage_connection_id,
+                               metadata              = EXCLUDED.metadata`;
+async function upsertSynthesizer(client, args) {
+    await client.query({
+        text: exports.upsertSynthesizerQuery,
+        values: [args.id, args.organizationId, args.name, args.description, args.storageConnectionId, args.metadata],
+        rowMode: "array"
+    });
+}
+exports.getSynthesizerQuery = `-- name: GetSynthesizer :one
+SELECT id, organization_id, name, description, storage_connection_id, metadata
+FROM synthesize_v1.synthesizer
+WHERE id = $1`;
+async function getSynthesizer(client, args) {
+    const result = await client.query({
+        text: exports.getSynthesizerQuery,
+        values: [args.id],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        name: row[2],
+        description: row[3],
+        storageConnectionId: row[4],
+        metadata: row[5]
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weave-typescript",
-  "version": "0.5.1",
+  "version": "0.8.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -28,6 +28,9 @@
       "default": "./dist/*.js"
     }
   },
+  "devDependencies": {
+    "@types/pg": "^8.15.5"
+  },
   "scripts": {
     "test": "node tools/sqlcgen.test.js",
     "test:sqlcgen": "node tools/sqlcgen.test.js",