@hazeljs/data 0.2.0-beta.68 → 0.2.0-beta.69

package/dist/schema/schema.test.js

@@ -116,4 +116,296 @@ describe('Schema', () => {
             expect(schema_1.Schema.array(schema_1.Schema.string()).validate({}).success).toBe(false);
         });
     });
+    describe('boolean', () => {
+        it('validates boolean', () => {
+            expect(schema_1.Schema.boolean().validate(true).success).toBe(true);
+            expect(schema_1.Schema.boolean().validate(false).success).toBe(true);
+            expect(schema_1.Schema.boolean().validate(1).success).toBe(false);
+        });
+    });
+    describe('literal', () => {
+        it('validates literal value', () => {
+            expect(schema_1.Schema.literal('active').validate('active').success).toBe(true);
+            expect(schema_1.Schema.literal('active').validate('inactive').success).toBe(false);
+            expect(schema_1.Schema.literal(42).validate(42).success).toBe(true);
+        });
+    });
+    describe('union', () => {
+        it('validates union of schemas', () => {
+            const schema = schema_1.Schema.union([schema_1.Schema.literal('a'), schema_1.Schema.literal('b')]);
+            expect(schema.validate('a').success).toBe(true);
+            expect(schema.validate('b').success).toBe(true);
+            expect(schema.validate('c').success).toBe(false);
+        });
+    });
+    describe('optional and default', () => {
+        it('optional accepts undefined', () => {
+            const schema = schema_1.Schema.string().optional();
+            expect(schema.validate(undefined).success).toBe(true);
+            expect(schema.validate('x').success).toBe(true);
+        });
+        it('default returns default for undefined', () => {
+            const schema = schema_1.Schema.string().default('fallback');
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('fallback');
+        });
+    });
+    describe('transform and refine', () => {
+        it('transform coerces after validation', () => {
+            const schema = schema_1.Schema.number().transform((n) => n * 2);
+            const result = schema.validate(21);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('refine adds custom constraint', () => {
+            const schema = schema_1.Schema.number().refine((n) => n % 2 === 0, 'Must be even');
+            expect(schema.validate(4).success).toBe(true);
+            expect(schema.validate(3).success).toBe(false);
+        });
+    });
+    describe('toJsonSchema', () => {
+        it('exports string schema', () => {
+            const js = schema_1.Schema.string().toJsonSchema();
+            expect(js).toMatchObject({ type: 'string' });
+        });
+        it('exports object schema', () => {
+            const schema = schema_1.Schema.object({ name: schema_1.Schema.string() });
+            const js = schema.toJsonSchema();
+            expect(js).toMatchObject({ type: 'object' });
+            expect(js).toHaveProperty('properties');
+        });
+        it('exports array schema', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const js = schema.toJsonSchema();
+            expect(js).toMatchObject({ type: 'array' });
+            expect(js).toHaveProperty('items');
+        });
+        it('exports literal schema', () => {
+            const js = schema_1.Schema.literal('x').toJsonSchema();
+            expect(js).toMatchObject({ const: 'x' });
+        });
+    });
+    describe('nullable', () => {
+        it('accepts null', () => {
+            const schema = schema_1.Schema.string().nullable();
+            expect(schema.validate(null).success).toBe(true);
+            expect(schema.validate('x').success).toBe(true);
+        });
+    });
+    describe('validateAsync', () => {
+        it('validates with async refinements', async () => {
+            const schema = schema_1.Schema.number().refineAsync(async (n) => n > 0, 'Must be positive');
+            const result = await schema.validateAsync(5);
+            expect(result.success).toBe(true);
+            const fail = await schema.validateAsync(-1);
+            expect(fail.success).toBe(false);
+        });
+    });
+    describe('number integer and url', () => {
+        it('integer rejects decimals', () => {
+            expect(schema_1.Schema.number().integer().validate(5).success).toBe(true);
+            expect(schema_1.Schema.number().integer().validate(5.5).success).toBe(false);
+        });
+        it('string url validates', () => {
+            expect(schema_1.Schema.string().url().validate('https://example.com').success).toBe(true);
+            expect(schema_1.Schema.string().url().validate('not-a-url').success).toBe(false);
+        });
+    });
+    describe('object pick omit extend strict', () => {
+        const base = schema_1.Schema.object({ a: schema_1.Schema.number(), b: schema_1.Schema.string(), c: schema_1.Schema.boolean() });
+        it('pick selects keys', () => {
+            const picked = base.pick(['a', 'c']);
+            const result = picked.validate({ a: 1, b: 'x', c: true });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({ a: 1, c: true });
+            }
+        });
+        it('omit removes keys', () => {
+            const omitted = base.omit(['b']);
+            const result = omitted.validate({ a: 1, b: 'x', c: true });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({ a: 1, c: true });
+            }
+        });
+        it('extend adds fields', () => {
+            const extended = base.extend({ d: schema_1.Schema.number() });
+            const result = extended.validate({ a: 1, b: 'x', c: true, d: 4 });
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data.d).toBe(4);
+        });
+        it('strict rejects unknown keys', () => {
+            const strict = base.strict();
+            const result = strict.validate({ a: 1, b: 'x', c: true, extra: 'bad' });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('array min max nonempty', () => {
+        it('min rejects short arrays', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number()).min(2);
+            expect(schema.validate([1, 2]).success).toBe(true);
+            expect(schema.validate([1]).success).toBe(false);
+        });
+        it('nonempty rejects empty', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.string()).nonempty();
+            expect(schema.validate(['x']).success).toBe(true);
+            expect(schema.validate([]).success).toBe(false);
+        });
+    });
+    describe('transform throws', () => {
+        it('transform error is caught', () => {
+            const schema = schema_1.Schema.number().transform((n) => {
+                if (n < 0)
+                    throw new Error('Negative');
+                return n;
+            });
+            const result = schema.validate(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Negative');
+        });
+        it('transform non-Error throw uses generic message', () => {
+            const schema = schema_1.Schema.number().transform(() => {
+                throw 'string error';
+            });
+            const result = schema.validate(1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Transform failed');
+        });
+    });
+    describe('string pattern required trim', () => {
+        it('pattern validates regex', () => {
+            expect(schema_1.Schema.string().pattern(/^\d+$/).validate('123').success).toBe(true);
+            expect(schema_1.Schema.string().pattern(/^\d+$/, 'Digits only').validate('abc').success).toBe(false);
+        });
+        it('required rejects empty string', () => {
+            expect(schema_1.Schema.string().required().validate('x').success).toBe(true);
+            expect(schema_1.Schema.string().required().validate('').success).toBe(false);
+        });
+        it('trim preprocesses', () => {
+            const result = schema_1.Schema.string().trim().validate('  hi  ');
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('hi');
+        });
+    });
+    describe('number positive negative multipleOf', () => {
+        it('positive rejects zero and negative', () => {
+            expect(schema_1.Schema.number().positive().validate(1).success).toBe(true);
+            expect(schema_1.Schema.number().positive().validate(0).success).toBe(false);
+            expect(schema_1.Schema.number().positive().validate(-1).success).toBe(false);
+        });
+        it('negative rejects zero and positive', () => {
+            expect(schema_1.Schema.number().negative().validate(-1).success).toBe(true);
+            expect(schema_1.Schema.number().negative().validate(0).success).toBe(false);
+        });
+        it('multipleOf validates', () => {
+            expect(schema_1.Schema.number().multipleOf(5).validate(10).success).toBe(true);
+            expect(schema_1.Schema.number().multipleOf(5).validate(7).success).toBe(false);
+        });
+    });
+    describe('number and boolean default', () => {
+        it('number default for undefined', () => {
+            const schema = schema_1.Schema.number().default(42);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('boolean default for undefined', () => {
+            const schema = schema_1.Schema.boolean().default(true);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(true);
+        });
+    });
+    describe('date min max default', () => {
+        it('date min max', () => {
+            const min = new Date('2024-01-01');
+            const max = new Date('2024-12-31');
+            const schema = schema_1.Schema.date().min(min).max(max);
+            expect(schema.validate(new Date('2024-06-15')).success).toBe(true);
+            expect(schema.validate(new Date('2023-06-15')).success).toBe(false);
+            expect(schema.validate(new Date('2025-06-15')).success).toBe(false);
+        });
+        it('date default for undefined', () => {
+            const d = new Date('2024-01-01');
+            const schema = schema_1.Schema.date().default(d);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual(d);
+        });
+    });
+    describe('nullable toJsonSchema', () => {
+        it('nullable string has type array', () => {
+            const js = schema_1.Schema.string().nullable().toJsonSchema();
+            expect(js.type).toEqual(['string', 'null']);
+        });
+        it('nullable without base type', () => {
+            const schema = schema_1.Schema.literal('x').nullable();
+            const js = schema.toJsonSchema();
+            expect(js.type).toEqual(['null']);
+        });
+    });
+    describe('optional toJsonSchema', () => {
+        it('optional has _optional flag', () => {
+            const js = schema_1.Schema.string().optional().toJsonSchema();
+            expect(js._optional).toBe(true);
+        });
+    });
+    describe('object pick filters keys not in shape', () => {
+        it('pick ignores keys not in shape', () => {
+            const base = schema_1.Schema.object({ a: schema_1.Schema.number() });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const picked = base.pick(['a', 'nonexistent']);
+            const result = picked.validate({ a: 1 });
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual({ a: 1 });
+        });
+    });
+    describe('array max', () => {
+        it('max rejects long arrays', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number()).max(2);
+            expect(schema.validate([1, 2]).success).toBe(true);
+            expect(schema.validate([1, 2, 3]).success).toBe(false);
+        });
+    });
+    describe('refineAsync', () => {
+        it('refineAsync failure path', async () => {
+            const schema = schema_1.Schema.number().refineAsync(async (n) => n > 10, 'Must be > 10');
+            const result = await schema.validateAsync(5);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Must be > 10');
+        });
+    });
+    describe('buildSchema refine failure', () => {
+        it('sync refine failure returns error', () => {
+            const schema = schema_1.Schema.number().refine((n) => n > 0, 'Must be positive');
+            const result = schema.validate(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Must be positive');
+        });
+    });
+    describe('validateAsync with sync failure', () => {
+        it('returns sync failure without running async refinements', async () => {
+            const schema = schema_1.Schema.number()
+                .refine((n) => n > 0, 'sync fail')
+                .refineAsync(async () => true, 'async');
+            const result = await schema.validateAsync(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('sync fail');
+        });
+    });
 });

package/dist/streaming/flink/flink.client.d.ts

@@ -48,11 +48,49 @@ export declare class FlinkClient {
         'slots-total'?: number;
     }>;
     getTaskManagers(): Promise<unknown[]>;
+    /**
+     * Upload a JAR file to the Flink cluster.
+     * @param jarPath Local filesystem path to the JAR file
+     * @returns The Flink JAR ID for subsequent run calls
+     */
+    uploadJar(jarPath: string): Promise<string>;
+    /**
+     * Run a previously uploaded JAR as a Flink job.
+     * @param jarId   The JAR ID returned by uploadJar()
+     * @param request Optional run parameters (entry class, parallelism, args, etc.)
+     * @returns The Flink job ID
+     */
+    runJar(jarId: string, request?: FlinkJobSubmitRequest): Promise<string>;
+    /**
+     * Submit a SQL statement to the Flink SQL Gateway.
+     * Requires Flink SQL Gateway to be running.
+     * @param sql       The SQL statement to execute (CREATE TABLE, INSERT INTO, etc.)
+     * @param sessionId An existing Flink SQL Gateway session ID
+     */
+    submitSql(sql: string, sessionId: string): Promise<string>;
+    /**
+     * Create a new SQL Gateway session.
+     * @returns The session ID
+     */
+    createSqlSession(properties?: Record<string, string>): Promise<string>;
     /**
      * Submit a job to Flink cluster.
-     * Note: Actual JAR submission requires Flink's /jars endpoint.
-     * This provides the interface; implementation depends on deployment setup.
+     * Requires `jarFile` path in the jobConfig or uses FlinkJobSubmitRequest.jarFile.
+     *
+     * Workflow: upload JAR → run JAR → return job ID.
+     */
+    submitJob(jobConfig: FlinkJobConfig, request?: FlinkJobSubmitRequest): Promise<string>;
+    /**
+     * List uploaded JARs on the cluster.
+     */
+    listJars(): Promise<Array<{
+        id: string;
+        name: string;
+        uploaded: number;
+    }>>;
+    /**
+     * Delete an uploaded JAR from the cluster.
      */
-    submitJob(_jobConfig: FlinkJobConfig, _jobGraph?: unknown): Promise<string>;
+    deleteJar(jarId: string): Promise<void>;
 }
 //# sourceMappingURL=flink.client.d.ts.map

package/dist/streaming/flink/flink.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flink.client.d.ts","sourceRoot":"","sources":["../../../src/streaming/flink/flink.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,MAAM,EAAE,iBAAiB;YASvB,OAAO;IA4Cf,QAAQ,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA+BnC,YAAY,CAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAY9D,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKjF,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKzF,cAAc,IAAI,OAAO,CAAC;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI5E,eAAe,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAK3C;;;;OAIG;IACG,SAAS,CAAC,UAAU,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CASlF"}
+{"version":3,"file":"flink.client.d.ts","sourceRoot":"","sources":["../../../src/streaming/flink/flink.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,MAAM,EAAE,iBAAiB;YASvB,OAAO;IA4Cf,QAAQ,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA+BnC,YAAY,CAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAY9D,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKjF,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKzF,cAAc,IAAI,OAAO,CAAC;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI5E,eAAe,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAK3C;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA8DjD;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC;IAejF;;;;;OAKG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWhE;;;OAGG;IACG,gBAAgB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAW5E;;;;;OAKG;IACG,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBhG;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAOhF;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG9C"}

package/dist/streaming/flink/flink.client.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlinkClient = void 0;
 /**
@@ -88,17 +121,147 @@ class FlinkClient {
         const result = await this.request('GET', '/taskmanagers');
         return result.taskmanagers ?? [];
     }
+    /**
+     * Upload a JAR file to the Flink cluster.
+     * @param jarPath Local filesystem path to the JAR file
+     * @returns The Flink JAR ID for subsequent run calls
+     */
+    async uploadJar(jarPath) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        if (!fs.existsSync(jarPath)) {
+            throw new Error(`JAR file not found: ${jarPath}`);
+        }
+        const url = `${this.url}/jars/upload`;
+        const fileName = path.basename(jarPath);
+        const fileBuffer = fs.readFileSync(jarPath);
+        const headers = {};
+        if (this.config.auth?.type === 'basic' && this.config.auth.username) {
+            headers['Authorization'] =
+                `Basic ${Buffer.from(`${this.config.auth.username}:${this.config.auth.password ?? ''}`).toString('base64')}`;
+        }
+        else if (this.config.auth?.type === 'token' && this.config.auth.token) {
+            headers['Authorization'] = `Bearer ${this.config.auth.token}`;
+        }
+        const boundary = `----HazelJSFormBoundary${Date.now()}`;
+        const bodyParts = [
+            Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="jarfile"; filename="${fileName}"\r\nContent-Type: application/java-archive\r\n\r\n`),
+            fileBuffer,
+            Buffer.from(`\r\n--${boundary}--\r\n`),
+        ];
+        const body = Buffer.concat(bodyParts);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    ...headers,
+                    'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                    'Content-Length': String(body.length),
+                },
+                body,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`Flink JAR upload failed ${response.status}: ${await response.text()}`);
+            }
+            const result = (await response.json());
+            const filename = result.filename ?? '';
+            const match = /\/jars\/([^/]+)$/.exec(filename);
+            if (!match)
+                throw new Error(`Could not extract JAR ID from Flink response: ${filename}`);
+            return match[1];
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            throw error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    /**
+     * Run a previously uploaded JAR as a Flink job.
+     * @param jarId   The JAR ID returned by uploadJar()
+     * @param request Optional run parameters (entry class, parallelism, args, etc.)
+     * @returns The Flink job ID
+     */
+    async runJar(jarId, request = {}) {
+        const body = {};
+        if (request.jobName)
+            body['job-name'] = request.jobName;
+        if (request.parallelism)
+            body['parallelism'] = request.parallelism;
+        if (request.entryClass)
+            body['entry-class'] = request.entryClass;
+        if (request.programArgs)
+            body['program-args'] = request.programArgs;
+        if (request.savepointPath)
+            body['savepointPath'] = request.savepointPath;
+        if (request.allowNonRestoredState)
+            body['allowNonRestoredState'] = request.allowNonRestoredState;
+        const result = await this.request('POST', `/jars/${jarId}/run`, body);
+        if (!result.jobid)
+            throw new Error('Flink did not return a job ID');
+        return result.jobid;
+    }
+    /**
+     * Submit a SQL statement to the Flink SQL Gateway.
+     * Requires Flink SQL Gateway to be running.
+     * @param sql       The SQL statement to execute (CREATE TABLE, INSERT INTO, etc.)
+     * @param sessionId An existing Flink SQL Gateway session ID
+     */
+    async submitSql(sql, sessionId) {
+        const result = await this.request('POST', `/sessions/${sessionId}/statements`, { statement: sql });
+        const id = result.operationHandle?.identifier;
+        if (!id)
+            throw new Error('Flink SQL Gateway did not return an operation handle');
+        return id;
+    }
+    /**
+     * Create a new SQL Gateway session.
+     * @returns The session ID
+     */
+    async createSqlSession(properties) {
+        const result = await this.request('POST', '/sessions', { properties: properties ?? {} });
+        const id = result.sessionHandle?.identifier;
+        if (!id)
+            throw new Error('Flink SQL Gateway did not return a session handle');
+        return id;
+    }
     /**
      * Submit a job to Flink cluster.
-     * Note: Actual JAR submission requires Flink's /jars endpoint.
-     * This provides the interface; implementation depends on deployment setup.
+     * Requires `jarFile` path in the jobConfig or uses FlinkJobSubmitRequest.jarFile.
+     *
+     * Workflow: upload JAR → run JAR → return job ID.
+     */
+    async submitJob(jobConfig, request = {}) {
+        const jarFile = request.jarFile;
+        if (!jarFile) {
+            throw new Error('submitJob requires a JAR file path. Set request.jarFile to the path of your pipeline JAR, ' +
+                'or use submitSql() for Flink SQL-based pipelines.');
+        }
+        const jarId = await this.uploadJar(jarFile);
+        return this.runJar(jarId, {
+            jobName: request.jobName ?? jobConfig.jobName,
+            parallelism: request.parallelism ?? jobConfig.parallelism,
+            entryClass: request.entryClass,
+            programArgs: request.programArgs,
+            savepointPath: request.savepointPath,
+            allowNonRestoredState: request.allowNonRestoredState,
+        });
+    }
+    /**
+     * List uploaded JARs on the cluster.
+     */
+    async listJars() {
+        const result = await this.request('GET', '/jars');
+        return result.files ?? [];
+    }
+    /**
+     * Delete an uploaded JAR from the cluster.
      */
-    async submitJob(_jobConfig, _jobGraph) {
-        // Flink REST API submits jobs via JAR upload and run
-        // For now return a placeholder - full implementation would:
-        // 1. Upload JAR to /jars
-        // 2. Create job from JAR via /jars/:jarid/run
-        throw new Error('submitJob: Full Flink deployment requires JAR submission. Use FlinkService.deployStream() for pipeline-to-job conversion.');
+    async deleteJar(jarId) {
+        await this.request('DELETE', `/jars/${jarId}`);
     }
 }
 exports.FlinkClient = FlinkClient;

package/dist/streaming/flink/flink.client.test.js

@@ -40,8 +40,8 @@ describe('FlinkClient', () => {
         mockFetch.mockResolvedValue({ ok: false, text: () => Promise.resolve('Not found') });
         await expect(client.getJobStatus('bad')).rejects.toThrow('Flink API error');
     });
-    it('submitJob throws with helpful message', async () => {
-        await expect(client.submitJob({})).rejects.toThrow('submitJob: Full Flink deployment requires');
+    it('submitJob requires a jarFile path', async () => {
+        await expect(client.submitJob({})).rejects.toThrow('submitJob requires a JAR file path');
     });
     it('getClusterInfo', async () => {
         mockFetch.mockResolvedValue({

package/dist/streaming/flink/flink.job.d.ts

@@ -1,5 +1,6 @@
 import { FlinkClient } from './flink.client';
 import type { FlinkJobConfig } from '../../data.types';
+import type { FlinkJobSubmitRequest } from './flink.client';
 export interface FlinkJobResult {
     jobId: string;
     status: string;
@@ -23,6 +24,6 @@ export declare class FlinkJob {
     stop(jobId: string, savepointPath?: string): Promise<{
         'request-id': string;
     }>;
-    submit(config: FlinkJobConfig, jobGraph?: unknown): Promise<string>;
+    submit(config: FlinkJobConfig, request?: FlinkJobSubmitRequest): Promise<string>;
 }
 //# sourceMappingURL=flink.job.d.ts.map

package/dist/streaming/flink/flink.job.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flink.job.d.ts","sourceRoot":"","sources":["../../../src/streaming/flink/flink.job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,WAAW;IAE1C,SAAS,CACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI9D,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAIzF,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAI9E,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAG1E"}
+{"version":3,"file":"flink.job.d.ts","sourceRoot":"","sources":["../../../src/streaming/flink/flink.job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,WAAW;IAE1C,SAAS,CACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI9D,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAIzF,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAI9E,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC;CAGvF"}

package/dist/streaming/flink/flink.job.js

@@ -20,8 +20,8 @@ class FlinkJob {
     async stop(jobId, savepointPath) {
         return this.client.stopJob(jobId, savepointPath);
     }
-    async submit(config, jobGraph) {
-        return this.client.submitJob(config, jobGraph);
+    async submit(config, request) {
+        return this.client.submitJob(config, request);
     }
 }
 exports.FlinkJob = FlinkJob;

package/dist/streaming/stream.processor.d.ts

@@ -1,12 +1,66 @@
 import { ETLService } from '../pipelines/etl.service';
+export interface WindowedBatch<T> {
+    items: T[];
+    windowStart: number;
+    windowEnd: number;
+}
 /**
- * Stream Processor - In-process stream processing logic
- * Processes items through pipeline without Flink (for testing/simple use cases)
+ * Stream Processor — in-process stream processing.
+ *
+ * Features:
+ * - `processItem` / `processStream` — single-item and async-generator streaming
+ * - `tumblingWindow` — non-overlapping time windows
+ * - `slidingWindow` — overlapping time windows
+ * - `sessionWindow` — gap-based grouping (items grouped when gap > idleMs)
+ * - `joinStreams` — merge two async iterables by matching key
  */
 export declare class StreamProcessor {
     private readonly etlService;
     constructor(etlService: ETLService);
     processItem<T>(pipelineInstance: object, item: unknown): Promise<T>;
     processStream<T>(pipelineInstance: object, source: AsyncIterable<unknown>): AsyncGenerator<T>;
+    /**
+     * Tumbling window — collects items into non-overlapping fixed-size time windows.
+     * Each item is assigned to exactly one window.
+     *
+     * @param source    Async iterable of `{ value: T; timestamp: number }` items
+     * @param windowMs  Window duration in milliseconds
+     */
+    tumblingWindow<T>(source: AsyncIterable<{
+        value: T;
+        timestamp: number;
+    }>, windowMs: number): AsyncGenerator<WindowedBatch<T>>;
+    /**
+     * Sliding window — each item may appear in multiple windows.
+     *
+     * @param source   Async iterable of `{ value: T; timestamp: number }` items
+     * @param windowMs Window size in milliseconds
+     * @param slideMs  Slide interval in milliseconds (how often a new window starts)
+     */
+    slidingWindow<T>(source: AsyncIterable<{
+        value: T;
+        timestamp: number;
+    }>, windowMs: number, slideMs: number): AsyncGenerator<WindowedBatch<T>>;
+    /**
+     * Session window — groups items by inactivity gaps.
+     * A new window starts when no item is received for longer than `idleMs`.
+     *
+     * @param source  Async iterable of items (with optional `.timestamp`)
+     * @param idleMs  Gap duration that triggers a new session (default: 30_000ms)
+     * @param getTimestamp Function to extract timestamp from an item (default: Date.now())
+     */
+    sessionWindow<T>(source: AsyncIterable<T>, idleMs: number, getTimestamp?: (item: T) => number): AsyncGenerator<WindowedBatch<T>>;
+    /**
+     * Join two async streams by a key function.
+     * Items from `left` are buffered; when a matching `right` item arrives, they are emitted together.
+     *
+     * @param left       Left stream
+     * @param right      Right stream
+     * @param leftKey    Extract join key from left items
+     * @param rightKey   Extract join key from right items
+     * @param merge      Combine matched left + right items
+     * @param windowMs   How long to buffer unmatched left items (default: 60_000ms)
+     */
+    joinStreams<L, R, Out>(left: AsyncIterable<L>, right: AsyncIterable<R>, leftKey: (item: L) => string, rightKey: (item: R) => string, merge: (l: L, r: R) => Out, windowMs?: number): AsyncGenerator<Out>;
 }
 //# sourceMappingURL=stream.processor.d.ts.map